lustre/llite/vvp_req.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2014, Intel Corporation.
  27  */
  28
  29 #define DEBUG_SUBSYSTEM S_LLITE
  30
  31 #include <lustre/lustre_idl.h>
  32 #include <cl_object.h>
  33 #include <obd.h>
  34 #include <obd_support.h>
  35 #include "llite_internal.h"
  36 #include "vvp_internal.h"
  37
  38 static inline struct vvp_req *cl2vvp_req(const struct cl_req_slice *slice)
  39 {
  40         return container_of0(slice, struct vvp_req, vrq_cl);
  41 }
  42
  43 /**
  44  * Implementation of struct cl_req_operations::cro_attr_set() for VVP
  45  * layer. VVP is responsible for
  46  *
  47  *    - o_[mac]time
  48  *
  49  *    - o_mode
  50  *
  51  *    - o_parent_seq
  52  *
  53  *    - o_[ug]id
  54  *
  55  *    - o_parent_oid
  56  *
  57  *    - o_parent_ver
  58  *
  59  *    - o_ioepoch,
  60  *
  61  *  and capability.
  62  */
  63 static void vvp_req_attr_set(const struct lu_env *env,
  64                              const struct cl_req_slice *slice,
  65                              const struct cl_object *obj,
  66                              struct cl_req_attr *attr, u64 flags)
  67 {
  68         struct inode    *inode;
  69         struct obdo     *oa;
  70         u32              valid_flags;
  71
  72         oa = attr->cra_oa;
  73         inode = vvp_object_inode(obj);
  74         valid_flags = OBD_MD_FLTYPE;
  75
  76         if ((flags & OBD_MD_FLOSSCAPA) != 0) {
  77                 LASSERT(attr->cra_capa == NULL);
  78                 attr->cra_capa = cl_capa_lookup(inode,
  79                                                 slice->crs_req->crq_type);
  80         }
  81
  82         if (slice->crs_req->crq_type == CRT_WRITE) {
  83                 if (flags & OBD_MD_FLEPOCH) {
  84                         oa->o_valid |= OBD_MD_FLEPOCH;
  85                         oa->o_ioepoch = ll_i2info(inode)->lli_ioepoch;
  86                         valid_flags |= OBD_MD_FLMTIME | OBD_MD_FLCTIME |
  87                                        OBD_MD_FLUID | OBD_MD_FLGID;
  88                 }
  89         }
  90
  91         obdo_from_inode(oa, inode, valid_flags & flags);
  92         obdo_set_parent_fid(oa, &ll_i2info(inode)->lli_fid);
  93         if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_INVALID_PFID))
  94                 oa->o_parent_oid++;
  95
  96         memcpy(attr->cra_jobid, ll_i2info(inode)->lli_jobid,
  97                LUSTRE_JOBID_SIZE);
  98 }
  99
 100 static void vvp_req_completion(const struct lu_env *env,
 101                                const struct cl_req_slice *slice, int ioret)
 102 {
 103         struct vvp_req *vrq;
 104
 105         if (ioret > 0)
 106                 cl_stats_tally(slice->crs_dev, slice->crs_req->crq_type, ioret);
 107
 108         vrq = cl2vvp_req(slice);
 109         OBD_SLAB_FREE_PTR(vrq, vvp_req_kmem);
 110 }
 111
 112 static const struct cl_req_operations vvp_req_ops = {
 113         .cro_attr_set   = vvp_req_attr_set,
 114         .cro_completion = vvp_req_completion,
 115 };
 116
 117 int vvp_req_init(const struct lu_env *env, struct cl_device *dev,
 118                  struct cl_req *req)
 119 {
 120         struct vvp_req *vrq;
 121         int result;
 122
 123         OBD_SLAB_ALLOC_PTR_GFP(vrq, vvp_req_kmem, GFP_NOFS);
 124         if (vrq != NULL) {
 125                 cl_req_slice_add(req, &vrq->vrq_cl, dev, &vvp_req_ops);
 126                 result = 0;
 127         } else {
 128                 result = -ENOMEM;
 129         }
 130
 131         return result;
 132 }