lustre/mds/mds_lib.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
  30  * Use is subject to license terms.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  */
  36
  37 #define DEBUG_SUBSYSTEM S_MDS
  38
  39 #ifndef AUTOCONF_INCLUDED
  40 #include <linux/config.h>
  41 #endif
  42 #include <linux/module.h>
  43 #include <linux/kernel.h>
  44 #include <linux/mm.h>
  45 #include <linux/string.h>
  46 #include <linux/stat.h>
  47 #include <linux/errno.h>
  48 #include <linux/version.h>
  49 #include <linux/buffer_head.h>   // for wait_on_buffer
  50 #include <linux/unistd.h>
  51
  52 #include <asm/system.h>
  53 #include <asm/uaccess.h>
  54
  55 #include <linux/fs.h>
  56 #include <linux/stat.h>
  57 #include <asm/uaccess.h>
  58 #include <linux/slab.h>
  59
  60 #include <obd_support.h>
  61 #include <lustre_lib.h>
  62 #include "mds_internal.h"
  63
  64 static void mds_pack_inode2fid(struct ll_fid *fid, struct inode *inode)
  65 {
  66         fid->id = inode->i_ino;
  67         fid->generation = inode->i_generation;
  68         fid->f_type = (S_IFMT & inode->i_mode);
  69 }
  70
  71 /* Note that we can copy all of the fields, just some will not be "valid" */
  72 void mds_pack_inode2body(struct mds_body *b, struct inode *inode)
  73 {
  74         b->valid |= OBD_MD_FLID | OBD_MD_FLCTIME | OBD_MD_FLUID |
  75                     OBD_MD_FLGID | OBD_MD_FLFLAGS | OBD_MD_FLTYPE |
  76                     OBD_MD_FLMODE | OBD_MD_FLNLINK | OBD_MD_FLGENER |
  77                     OBD_MD_FLATIME | OBD_MD_FLMTIME; /* bug 2020 */
  78
  79         if (!S_ISREG(inode->i_mode))
  80                 b->valid |= OBD_MD_FLSIZE | OBD_MD_FLBLOCKS | OBD_MD_FLATIME |
  81                             OBD_MD_FLMTIME | OBD_MD_FLRDEV;
  82
  83         mds_pack_inode2fid(&b->fid1, inode);
  84         b->ino = inode->i_ino;
  85         b->atime = LTIME_S(inode->i_atime);
  86         b->mtime = LTIME_S(inode->i_mtime);
  87         b->ctime = LTIME_S(inode->i_ctime);
  88         b->mode = inode->i_mode;
  89         b->size = i_size_read(inode);
  90         b->blocks = inode->i_blocks;
  91         b->uid = inode->i_uid;
  92         b->gid = inode->i_gid;
  93         b->flags = ll_inode_to_ext_flags(inode->i_flags, MDS_BFLAG_EXT_FLAGS);
  94         b->rdev = inode->i_rdev;
  95         /* Return the correct link count for orphan inodes */
  96         b->nlink = mds_inode_is_orphan(inode) ? 0 : inode->i_nlink;
  97         b->generation = inode->i_generation;
  98         b->suppgid = -1;
  99 }
 100
 101 static inline unsigned int attr_unpack(__u64 sa_valid) {
 102         unsigned int ia_valid = 0;
 103
 104         if (sa_valid & MDS_ATTR_MODE)
 105                 ia_valid |= ATTR_MODE;
 106         if (sa_valid & MDS_ATTR_UID)
 107                 ia_valid |= ATTR_UID;
 108         if (sa_valid & MDS_ATTR_GID)
 109                 ia_valid |= ATTR_GID;
 110         if (sa_valid & MDS_ATTR_SIZE)
 111                 ia_valid |= ATTR_SIZE;
 112         if (sa_valid & MDS_ATTR_ATIME)
 113                 ia_valid |= ATTR_ATIME;
 114         if (sa_valid & MDS_ATTR_MTIME)
 115                 ia_valid |= ATTR_MTIME;
 116         if (sa_valid & MDS_ATTR_CTIME)
 117                 ia_valid |= ATTR_CTIME;
 118         if (sa_valid & MDS_ATTR_ATIME_SET)
 119                 ia_valid |= ATTR_ATIME_SET;
 120         if (sa_valid & MDS_ATTR_MTIME_SET)
 121                 ia_valid |= ATTR_MTIME_SET;
 122         if (sa_valid & MDS_ATTR_FORCE)
 123                 ia_valid |= ATTR_FORCE;
 124         if (sa_valid & MDS_ATTR_ATTR_FLAG)
 125                 ia_valid |= ATTR_ATTR_FLAG;
 126         if (sa_valid & MDS_ATTR_KILL_SUID)
 127                 ia_valid |=  ATTR_KILL_SUID;
 128         if (sa_valid & MDS_ATTR_KILL_SGID)
 129                 ia_valid |= ATTR_KILL_SGID;
 130         if (sa_valid & MDS_ATTR_CTIME_SET)
 131                 ia_valid |= ATTR_CTIME_SET;
 132         if (sa_valid & MDS_ATTR_FROM_OPEN)
 133                 ia_valid |= ATTR_FROM_OPEN;
 134         if (sa_valid & MDS_OPEN_OWNEROVERRIDE)
 135                 ia_valid |= MDS_OPEN_OWNEROVERRIDE;
 136         return ia_valid;
 137 }
 138
 139 /* unpacking */
 140 static int mds_setattr_unpack(struct ptlrpc_request *req, int offset,
 141                               struct mds_update_record *r)
 142 {
 143         struct iattr *attr = &r->ur_iattr;
 144         struct mds_rec_setattr *rec;
 145         ENTRY;
 146
 147         rec = lustre_swab_reqbuf(req, offset, sizeof(*rec),
 148                                  lustre_swab_mds_rec_setattr);
 149         if (rec == NULL)
 150                 RETURN (-EFAULT);
 151
 152         r->ur_uc.luc_fsuid = rec->sa_fsuid;
 153         r->ur_uc.luc_fsgid = rec->sa_fsgid;
 154         cfs_kernel_cap_unpack(&r->ur_uc.luc_cap, rec->sa_cap);
 155         r->ur_uc.luc_suppgid1 = rec->sa_suppgid;
 156         r->ur_uc.luc_suppgid2 = -1;
 157         r->ur_fid1 = &rec->sa_fid;
 158         attr->ia_valid = attr_unpack(rec->sa_valid);
 159         attr->ia_mode = rec->sa_mode;
 160         attr->ia_uid = rec->sa_uid;
 161         attr->ia_gid = rec->sa_gid;
 162         attr->ia_size = rec->sa_size;
 163         LTIME_S(attr->ia_atime) = rec->sa_atime;
 164         LTIME_S(attr->ia_mtime) = rec->sa_mtime;
 165         LTIME_S(attr->ia_ctime) = rec->sa_ctime;
 166         r->ur_flags = rec->sa_attr_flags;
 167
 168         lustre_set_req_swabbed(req, offset + 1);
 169         r->ur_eadatalen = lustre_msg_buflen(req->rq_reqmsg, offset + 1);
 170         if (r->ur_eadatalen) {
 171                 r->ur_eadata = lustre_msg_buf(req->rq_reqmsg, offset + 1, 0);
 172                 if (r->ur_eadata == NULL)
 173                         RETURN(-EFAULT);
 174         }
 175         r->ur_cookielen = lustre_msg_buflen(req->rq_reqmsg, offset + 2);
 176         if (r->ur_cookielen) {
 177                 r->ur_logcookies = lustre_msg_buf(req->rq_reqmsg, offset + 2,0);
 178                 if (r->ur_eadata == NULL)
 179                         RETURN (-EFAULT);
 180         }
 181         if (lustre_msg_buflen(req->rq_reqmsg, offset + 3)) {
 182                 r->ur_dlm = lustre_swab_reqbuf(req, offset + 3,
 183                                                sizeof(*r->ur_dlm),
 184                                                lustre_swab_ldlm_request);
 185                 if (r->ur_dlm == NULL)
 186                         RETURN (-EFAULT);
 187         }
 188         RETURN(0);
 189 }
 190
 191 static int mds_create_unpack(struct ptlrpc_request *req, int offset,
 192                              struct mds_update_record *r)
 193 {
 194         struct mds_rec_create *rec;
 195         ENTRY;
 196
 197         rec = lustre_swab_reqbuf(req, offset, sizeof (*rec),
 198                                  lustre_swab_mds_rec_create);
 199         if (rec == NULL)
 200                 RETURN (-EFAULT);
 201
 202         r->ur_uc.luc_fsuid = rec->cr_fsuid;
 203         r->ur_uc.luc_fsgid = rec->cr_fsgid;
 204         cfs_kernel_cap_unpack(&r->ur_uc.luc_cap, rec->cr_cap);
 205         r->ur_uc.luc_suppgid1 = rec->cr_suppgid;
 206         r->ur_uc.luc_suppgid2 = -1;
 207         r->ur_fid1 = &rec->cr_fid;
 208         r->ur_fid2 = &rec->cr_replayfid;
 209         r->ur_mode = rec->cr_mode;
 210         r->ur_rdev = rec->cr_rdev;
 211         r->ur_time = rec->cr_time;
 212         r->ur_flags = rec->cr_flags;
 213
 214         lustre_set_req_swabbed(req, offset + 1);
 215         r->ur_name = lustre_msg_string(req->rq_reqmsg, offset + 1, 0);
 216         if (r->ur_name == NULL)
 217                 RETURN (-EFAULT);
 218         r->ur_namelen = lustre_msg_buflen(req->rq_reqmsg, offset + 1);
 219
 220         lustre_set_req_swabbed(req, offset + 2);
 221         r->ur_tgtlen = lustre_msg_buflen(req->rq_reqmsg, offset + 2);
 222         if (r->ur_tgtlen) {
 223                 /* NB for now, we only seem to pass NULL terminated symlink
 224                  * target strings here.  If this ever changes, we'll have
 225                  * to stop checking for a buffer filled completely with a
 226                  * NULL terminated string here, and make the callers check
 227                  * depending on what they expect.  We should probably stash
 228                  * it in r->ur_eadata in that case, so it's obvious... -eeb
 229                  */
 230                 r->ur_tgt = lustre_msg_string(req->rq_reqmsg, offset + 2, 0);
 231                 if (r->ur_tgt == NULL)
 232                         RETURN (-EFAULT);
 233         }
 234         if (lustre_msg_buflen(req->rq_reqmsg, offset + 3)) {
 235                 r->ur_dlm = lustre_swab_reqbuf(req, offset + 3,
 236                                                sizeof(*r->ur_dlm),
 237                                                lustre_swab_ldlm_request);
 238                 if (r->ur_dlm == NULL)
 239                         RETURN (-EFAULT);
 240         }
 241         RETURN(0);
 242 }
 243
 244 static int mds_link_unpack(struct ptlrpc_request *req, int offset,
 245                            struct mds_update_record *r)
 246 {
 247         struct mds_rec_link *rec;
 248         ENTRY;
 249
 250         rec = lustre_swab_reqbuf(req, offset, sizeof (*rec),
 251                                  lustre_swab_mds_rec_link);
 252         if (rec == NULL)
 253                 RETURN (-EFAULT);
 254
 255         r->ur_uc.luc_fsuid = rec->lk_fsuid;
 256         r->ur_uc.luc_fsgid = rec->lk_fsgid;
 257         cfs_kernel_cap_unpack(&r->ur_uc.luc_cap, rec->lk_cap);
 258         r->ur_uc.luc_suppgid1 = rec->lk_suppgid1;
 259         r->ur_uc.luc_suppgid2 = rec->lk_suppgid2;
 260         r->ur_fid1 = &rec->lk_fid1;
 261         r->ur_fid2 = &rec->lk_fid2;
 262         r->ur_time = rec->lk_time;
 263
 264         lustre_set_req_swabbed(req, offset + 1);
 265         r->ur_name = lustre_msg_string(req->rq_reqmsg, offset + 1, 0);
 266         if (r->ur_name == NULL)
 267                 RETURN (-EFAULT);
 268         r->ur_namelen = lustre_msg_buflen(req->rq_reqmsg, offset + 1);
 269         if (lustre_msg_buflen(req->rq_reqmsg, offset + 2)) {
 270                 r->ur_dlm = lustre_swab_reqbuf(req, offset + 2,
 271                                                sizeof(*r->ur_dlm),
 272                                                lustre_swab_ldlm_request);
 273                 if (r->ur_dlm == NULL)
 274                         RETURN (-EFAULT);
 275         }
 276         RETURN(0);
 277 }
 278
 279 static int mds_unlink_unpack(struct ptlrpc_request *req, int offset,
 280                              struct mds_update_record *r)
 281 {
 282         struct mds_rec_unlink *rec;
 283         ENTRY;
 284
 285         rec = lustre_swab_reqbuf(req, offset, sizeof (*rec),
 286                                  lustre_swab_mds_rec_unlink);
 287         if (rec == NULL)
 288                 RETURN(-EFAULT);
 289
 290         r->ur_uc.luc_fsuid = rec->ul_fsuid;
 291         r->ur_uc.luc_fsgid = rec->ul_fsgid;
 292         cfs_kernel_cap_unpack(&r->ur_uc.luc_cap, rec->ul_cap);
 293         r->ur_uc.luc_suppgid1 = rec->ul_suppgid;
 294         r->ur_uc.luc_suppgid2 = -1;
 295         r->ur_mode = rec->ul_mode;
 296         r->ur_fid1 = &rec->ul_fid1;
 297         r->ur_fid2 = &rec->ul_fid2;
 298         r->ur_time = rec->ul_time;
 299
 300         lustre_set_req_swabbed(req, offset + 1);
 301         r->ur_name = lustre_msg_string(req->rq_reqmsg, offset + 1, 0);
 302         if (r->ur_name == NULL)
 303                 RETURN(-EFAULT);
 304         r->ur_namelen = lustre_msg_buflen(req->rq_reqmsg, offset + 1);
 305         if (lustre_msg_buflen(req->rq_reqmsg, offset + 2)) {
 306                 r->ur_dlm = lustre_swab_reqbuf(req, offset + 2,
 307                                                sizeof(*r->ur_dlm),
 308                                                lustre_swab_ldlm_request);
 309                 if (r->ur_dlm == NULL)
 310                         RETURN (-EFAULT);
 311         }
 312         RETURN(0);
 313 }
 314
 315 static int mds_rename_unpack(struct ptlrpc_request *req, int offset,
 316                              struct mds_update_record *r)
 317 {
 318         struct mds_rec_rename *rec;
 319         ENTRY;
 320
 321         rec = lustre_swab_reqbuf(req, offset, sizeof (*rec),
 322                                  lustre_swab_mds_rec_rename);
 323         if (rec == NULL)
 324                 RETURN(-EFAULT);
 325
 326         r->ur_uc.luc_fsuid = rec->rn_fsuid;
 327         r->ur_uc.luc_fsgid = rec->rn_fsgid;
 328         cfs_kernel_cap_unpack(&r->ur_uc.luc_cap, rec->rn_cap);
 329         r->ur_uc.luc_suppgid1 = rec->rn_suppgid1;
 330         r->ur_uc.luc_suppgid2 = rec->rn_suppgid2;
 331         r->ur_fid1 = &rec->rn_fid1;
 332         r->ur_fid2 = &rec->rn_fid2;
 333         r->ur_time = rec->rn_time;
 334
 335         lustre_set_req_swabbed(req, offset + 1);
 336         r->ur_name = lustre_msg_string(req->rq_reqmsg, offset + 1, 0);
 337         if (r->ur_name == NULL)
 338                 RETURN(-EFAULT);
 339         r->ur_namelen = lustre_msg_buflen(req->rq_reqmsg, offset + 1);
 340
 341         lustre_set_req_swabbed(req, offset + 2);
 342         r->ur_tgt = lustre_msg_string(req->rq_reqmsg, offset + 2, 0);
 343         if (r->ur_tgt == NULL)
 344                 RETURN(-EFAULT);
 345         r->ur_tgtlen = lustre_msg_buflen(req->rq_reqmsg, offset + 2);
 346         if (lustre_msg_buflen(req->rq_reqmsg, offset + 3)) {
 347                 r->ur_dlm = lustre_swab_reqbuf(req, offset + 3,
 348                                                sizeof(*r->ur_dlm),
 349                                                lustre_swab_ldlm_request);
 350                 if (r->ur_dlm == NULL)
 351                         RETURN (-EFAULT);
 352         }
 353         RETURN(0);
 354 }
 355
 356 static int mds_open_unpack(struct ptlrpc_request *req, int offset,
 357                            struct mds_update_record *r)
 358 {
 359         struct mds_rec_create *rec;
 360         ENTRY;
 361
 362         rec = lustre_swab_reqbuf(req, offset, sizeof(*rec),
 363                                  lustre_swab_mds_rec_create);
 364         if (rec == NULL)
 365                 RETURN(-EFAULT);
 366
 367         r->ur_uc.luc_fsuid = rec->cr_fsuid;
 368         r->ur_uc.luc_fsgid = rec->cr_fsgid;
 369         cfs_kernel_cap_unpack(&r->ur_uc.luc_cap, rec->cr_cap);
 370         r->ur_uc.luc_suppgid1 = rec->cr_suppgid;
 371         r->ur_uc.luc_suppgid2 = -1;
 372         r->ur_fid1 = &rec->cr_fid;
 373         r->ur_fid2 = &rec->cr_replayfid;
 374         r->ur_mode = rec->cr_mode;
 375         r->ur_rdev = rec->cr_rdev;
 376         r->ur_time = rec->cr_time;
 377         r->ur_flags = rec->cr_flags;
 378
 379         lustre_set_req_swabbed(req, offset + 1);
 380         r->ur_name = lustre_msg_string(req->rq_reqmsg, offset + 1, 0);
 381         if (r->ur_name == NULL)
 382                 RETURN(-EFAULT);
 383         r->ur_namelen = lustre_msg_buflen(req->rq_reqmsg, offset + 1);
 384
 385         lustre_set_req_swabbed(req, offset + 2);
 386         r->ur_eadatalen = lustre_msg_buflen(req->rq_reqmsg, offset + 2);
 387         if (r->ur_eadatalen) {
 388                 r->ur_eadata = lustre_msg_buf(req->rq_reqmsg, offset + 2, 0);
 389                 if (r->ur_eadata == NULL)
 390                         RETURN (-EFAULT);
 391         }
 392         RETURN(0);
 393 }
 394
 395 typedef int (*update_unpacker)(struct ptlrpc_request *req, int offset,
 396                                struct mds_update_record *r);
 397
 398 static update_unpacker mds_unpackers[REINT_MAX] = {
 399         [REINT_SETATTR] mds_setattr_unpack,
 400         [REINT_CREATE] mds_create_unpack,
 401         [REINT_LINK] mds_link_unpack,
 402         [REINT_UNLINK] mds_unlink_unpack,
 403         [REINT_RENAME] mds_rename_unpack,
 404         [REINT_OPEN] mds_open_unpack,
 405 };
 406
 407 int mds_update_unpack(struct ptlrpc_request *req, int offset,
 408                       struct mds_update_record *rec)
 409 {
 410         mds_reint_t opcode, *opcodep;
 411         int rc;
 412         ENTRY;
 413
 414         /* NB don't lustre_swab_reqbuf() here.  We're just taking a peek
 415          * and we want to leave it to the specific unpacker once we've
 416          * identified the message type */
 417         opcodep = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*opcodep));
 418         if (opcodep == NULL)
 419                 RETURN(-EFAULT);
 420
 421         opcode = *opcodep;
 422         if (lustre_req_need_swab(req))
 423                 __swab32s(&opcode);
 424
 425         if (opcode >= REINT_MAX || mds_unpackers[opcode] == NULL) {
 426                 CERROR("Unexpected opcode %d\n", opcode);
 427                 RETURN(-EFAULT);
 428         }
 429
 430         rec->ur_opcode = opcode;
 431         rc = mds_unpackers[opcode](req, offset, rec);
 432
 433         RETURN(rc);
 434 }
 435
 436 void mds_root_squash(struct mds_obd *mds, lnet_nid_t *peernid,
 437                      __u32 *fsuid, __u32 *fsgid, cfs_kernel_cap_t *kcap,
 438                      __u32 *suppgid, __u32 *suppgid2)
 439 {
 440         if (!mds->mds_squash_uid || *fsuid)
 441                return;
 442
 443         if (*peernid == mds->mds_nosquash_nid)
 444                 return;
 445
 446         CDEBUG(D_OTHER, "squash req from %s, (%d:%d)=>(%d:%d)\n",
 447                libcfs_nid2str(*peernid), *fsuid, *fsgid,
 448                mds->mds_squash_uid, mds->mds_squash_gid);
 449
 450         *fsuid = mds->mds_squash_uid;
 451         *fsgid = mds->mds_squash_gid;
 452         cfs_kernel_cap_unpack(kcap, 0);
 453         *suppgid = -1;
 454         if (suppgid2)
 455                 *suppgid2 = -1;
 456 }
 457
 458 int mds_init_ucred(struct lvfs_ucred *ucred, struct ptlrpc_request *req,
 459                    int offset)
 460 {
 461         struct mds_body *body = lustre_msg_buf(req->rq_reqmsg, offset,
 462                                                sizeof(*body));
 463         struct mds_obd *mds = mds_req2mds(req);
 464         int rc;
 465
 466         LASSERT(body != NULL); /* previously verified & swabbed by caller */
 467
 468 #ifdef CRAY_XT3
 469         if (req->rq_uid != LNET_UID_ANY) {
 470                 /* Non-root local cluster client */
 471                 LASSERT (req->rq_uid != 0);
 472                 ucred->luc_fsuid = req->rq_uid;
 473         } else
 474 #endif
 475         {
 476                 cfs_kernel_cap_unpack(&ucred->luc_cap, body->capability);
 477                 mds_root_squash(mds, &req->rq_peer.nid, &body->fsuid,
 478                                 &body->fsgid, &ucred->luc_cap,
 479                                 &body->suppgid, NULL);
 480
 481                 ucred->luc_fsuid = body->fsuid;
 482                 ucred->luc_fsgid = body->fsgid;
 483         }
 484
 485         ucred->luc_uce = upcall_cache_get_entry(mds->mds_group_hash,
 486                                                 ucred->luc_fsuid,
 487                                                 ucred->luc_fsgid, 1,
 488                                                 &body->suppgid);
 489         if (IS_ERR(ucred->luc_uce)) {
 490                 rc = PTR_ERR(ucred->luc_uce);
 491                 ucred->luc_uce = NULL;
 492                 return rc;
 493         }
 494
 495 #ifdef CRAY_XT3
 496         if (ucred->luc_uce)
 497                 ucred->luc_fsgid = ucred->luc_uce->ue_primary;
 498 #endif
 499
 500         return 0;
 501 }
 502
 503 void mds_exit_ucred(struct lvfs_ucred *ucred, struct mds_obd *mds)
 504 {
 505         upcall_cache_put_entry(mds->mds_group_hash, ucred->luc_uce);
 506 }