lustre/ofd/ofd_lvb.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.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2011, 2012, Whamcloud, Inc.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * lustre/ofd/ofd_lvb.c
  37  *
  38  * Author: Mikhail Pershin <tappro@whamcloud.com>
  39  * Author: Alexey Zhuravlev <bzzz@whamcloud.com>
  40  */
  41
  42 #define DEBUG_SUBSYSTEM S_FILTER
  43
  44 #include "ofd_internal.h"
  45
  46 static int ofd_lvbo_free(struct ldlm_resource *res)
  47 {
  48         if (res->lr_lvb_data)
  49                 OBD_FREE(res->lr_lvb_data, res->lr_lvb_len);
  50
  51         return 0;
  52 }
  53
  54 /* Called with res->lr_lvb_sem held */
  55 static int ofd_lvbo_init(struct ldlm_resource *res)
  56 {
  57         struct ost_lvb          *lvb = NULL;
  58         struct ofd_device       *ofd;
  59         struct ofd_object       *fo;
  60         struct ofd_thread_info  *info;
  61         struct lu_env            env;
  62         int                      rc = 0;
  63
  64         ENTRY;
  65
  66         LASSERT(res);
  67         LASSERT_MUTEX_LOCKED(&res->lr_lvb_mutex);
  68
  69         if (res->lr_lvb_data != NULL)
  70                 RETURN(0);
  71
  72         ofd = ldlm_res_to_ns(res)->ns_lvbp;
  73         LASSERT(ofd != NULL);
  74
  75         rc = lu_env_init(&env, LCT_DT_THREAD);
  76         if (rc)
  77                 RETURN(rc);
  78
  79         OBD_ALLOC_PTR(lvb);
  80         if (lvb == NULL)
  81                 RETURN(-ENOMEM);
  82
  83         res->lr_lvb_data = lvb;
  84         res->lr_lvb_len = sizeof(*lvb);
  85
  86         info = ofd_info_init(&env, NULL);
  87         ofd_fid_from_resid(&info->fti_fid, &res->lr_name);
  88         fo = ofd_object_find(&env, ofd, &info->fti_fid);
  89         if (IS_ERR(fo))
  90                 GOTO(out, rc = PTR_ERR(fo));
  91
  92         rc = ofd_attr_get(&env, fo, &info->fti_attr);
  93         if (rc)
  94                 GOTO(out_put, rc);
  95
  96         lvb->lvb_size = info->fti_attr.la_size;
  97         lvb->lvb_blocks = info->fti_attr.la_blocks;
  98         lvb->lvb_mtime = info->fti_attr.la_mtime;
  99         lvb->lvb_atime = info->fti_attr.la_atime;
 100         lvb->lvb_ctime = info->fti_attr.la_ctime;
 101
 102         CDEBUG(D_DLMTRACE, "res: "LPX64" initial lvb size: "LPX64", "
 103                "mtime: "LPX64", blocks: "LPX64"\n",
 104                res->lr_name.name[0], lvb->lvb_size,
 105                lvb->lvb_mtime, lvb->lvb_blocks);
 106
 107         EXIT;
 108 out_put:
 109         ofd_object_put(&env, fo);
 110 out:
 111         lu_env_fini(&env);
 112         if (rc)
 113                 OST_LVB_SET_ERR(lvb->lvb_blocks, rc);
 114         /* Don't free lvb data on lookup error */
 115         return rc;
 116 }
 117
 118 /* This will be called in two ways:
 119  *
 120  *   r != NULL : called by the DLM itself after a glimpse callback
 121  *   r == NULL : called by the ofd after a disk write
 122  *
 123  *   If 'increase_only' is true, don't allow values to move backwards.
 124  */
 125 static int ofd_lvbo_update(struct ldlm_resource *res,
 126                            struct ptlrpc_request *req, int increase_only)
 127 {
 128         struct ofd_device       *ofd;
 129         struct ofd_object       *fo;
 130         struct ofd_thread_info  *info;
 131         struct ost_lvb          *lvb;
 132         struct lu_env            env;
 133         int                      rc = 0;
 134
 135         ENTRY;
 136
 137         LASSERT(res != NULL);
 138
 139         ofd = ldlm_res_to_ns(res)->ns_lvbp;
 140         LASSERT(ofd != NULL);
 141
 142         lvb = res->lr_lvb_data;
 143         if (lvb == NULL) {
 144                 CERROR("%s: no lvb when running lvbo_update, res: "LPU64"!\n",
 145                        ofd_obd(ofd)->obd_name, res->lr_name.name[0]);
 146                 RETURN(0);
 147         }
 148
 149         rc = lu_env_init(&env, LCT_DT_THREAD);
 150         if (rc)
 151                 GOTO(out_unlock, rc);
 152
 153         info = ofd_info_init(&env, NULL);
 154         /* Update the LVB from the network message */
 155         if (req != NULL) {
 156                 struct ost_lvb *rpc_lvb;
 157
 158                 /* XXX update always from reply buffer */
 159                 rpc_lvb = req_capsule_server_get(&req->rq_pill, &RMF_DLM_LVB);
 160                 if (rpc_lvb == NULL) {
 161                         CERROR("lustre_swab_buf failed\n");
 162                         goto disk_update;
 163                 }
 164                 lock_res(res);
 165                 if (rpc_lvb->lvb_size > lvb->lvb_size || !increase_only) {
 166                         CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb size: "
 167                                LPU64" -> "LPU64"\n", res->lr_name.name[0],
 168                                lvb->lvb_size, rpc_lvb->lvb_size);
 169                         lvb->lvb_size = rpc_lvb->lvb_size;
 170                 }
 171                 if (rpc_lvb->lvb_mtime > lvb->lvb_mtime || !increase_only) {
 172                         CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb mtime: "
 173                                LPU64" -> "LPU64"\n", res->lr_name.name[0],
 174                                lvb->lvb_mtime, rpc_lvb->lvb_mtime);
 175                         lvb->lvb_mtime = rpc_lvb->lvb_mtime;
 176                 }
 177                 if (rpc_lvb->lvb_atime > lvb->lvb_atime || !increase_only) {
 178                         CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb atime: "
 179                                LPU64" -> "LPU64"\n", res->lr_name.name[0],
 180                                lvb->lvb_atime, rpc_lvb->lvb_atime);
 181                         lvb->lvb_atime = rpc_lvb->lvb_atime;
 182                 }
 183                 if (rpc_lvb->lvb_ctime > lvb->lvb_ctime || !increase_only) {
 184                         CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb ctime: "
 185                                LPU64" -> "LPU64"\n", res->lr_name.name[0],
 186                                lvb->lvb_ctime, rpc_lvb->lvb_ctime);
 187                         lvb->lvb_ctime = rpc_lvb->lvb_ctime;
 188                 }
 189                 if (rpc_lvb->lvb_blocks > lvb->lvb_blocks || !increase_only) {
 190                         CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb blocks: "
 191                                LPU64" -> "LPU64"\n", res->lr_name.name[0],
 192                                lvb->lvb_blocks, rpc_lvb->lvb_blocks);
 193                         lvb->lvb_blocks = rpc_lvb->lvb_blocks;
 194                 }
 195                 unlock_res(res);
 196         }
 197
 198 disk_update:
 199         /* Update the LVB from the disk inode */
 200         ofd_fid_from_resid(&info->fti_fid, &res->lr_name);
 201         fo = ofd_object_find(&env, ofd, &info->fti_fid);
 202         if (IS_ERR(fo))
 203                 GOTO(out_env, rc = PTR_ERR(fo));
 204
 205         rc = ofd_attr_get(&env, fo, &info->fti_attr);
 206         if (rc)
 207                 GOTO(out_obj, rc);
 208
 209         lock_res(res);
 210         if (info->fti_attr.la_size > lvb->lvb_size || !increase_only) {
 211                 CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb size from disk: "
 212                        LPU64" -> %llu\n", res->lr_name.name[0],
 213                        lvb->lvb_size, info->fti_attr.la_size);
 214                 lvb->lvb_size = info->fti_attr.la_size;
 215         }
 216
 217         if (info->fti_attr.la_mtime >lvb->lvb_mtime || !increase_only) {
 218                 CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb mtime from disk: "
 219                        LPU64" -> "LPU64"\n", res->lr_name.name[0],
 220                        lvb->lvb_mtime, info->fti_attr.la_mtime);
 221                 lvb->lvb_mtime = info->fti_attr.la_mtime;
 222         }
 223         if (info->fti_attr.la_atime >lvb->lvb_atime || !increase_only) {
 224                 CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb atime from disk: "
 225                        LPU64" -> "LPU64"\n", res->lr_name.name[0],
 226                        lvb->lvb_atime, info->fti_attr.la_atime);
 227                 lvb->lvb_atime = info->fti_attr.la_atime;
 228         }
 229         if (info->fti_attr.la_ctime >lvb->lvb_ctime || !increase_only) {
 230                 CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb ctime from disk: "
 231                        LPU64" -> "LPU64"\n", res->lr_name.name[0],
 232                        lvb->lvb_ctime, info->fti_attr.la_ctime);
 233                 lvb->lvb_ctime = info->fti_attr.la_ctime;
 234         }
 235         if (info->fti_attr.la_blocks > lvb->lvb_blocks || !increase_only) {
 236                 CDEBUG(D_DLMTRACE,"res: "LPU64" updating lvb blocks from disk: "
 237                        LPU64" -> %llu\n", res->lr_name.name[0],
 238                        lvb->lvb_blocks,
 239                        (unsigned long long)info->fti_attr.la_blocks);
 240                 lvb->lvb_blocks = info->fti_attr.la_blocks;
 241         }
 242         unlock_res(res);
 243
 244 out_obj:
 245         ofd_object_put(&env, fo);
 246 out_env:
 247         lu_env_fini(&env);
 248 out_unlock:
 249         return rc;
 250 }
 251
 252 static int ofd_lvbo_size(struct ldlm_lock *unused)
 253 {
 254         return sizeof(struct ost_lvb);
 255 }
 256
 257 static int ofd_lvbo_fill(struct ldlm_lock *lock, void *buf, int buflen)
 258 {
 259         struct ldlm_resource *res = lock->l_resource;
 260
 261         lock_res(res);
 262         LASSERTF(buflen >= res->lr_lvb_len,
 263                  "actual %d, want %d\n", buflen, res->lr_lvb_len);
 264         memcpy(buf, res->lr_lvb_data, res->lr_lvb_len);
 265         unlock_res(res);
 266
 267         return res->lr_lvb_len;
 268 }
 269
 270 struct ldlm_valblock_ops ofd_lvbo = {
 271         lvbo_init:      ofd_lvbo_init,
 272         lvbo_update:    ofd_lvbo_update,
 273         lvbo_free:      ofd_lvbo_free,
 274         lvbo_size:      ofd_lvbo_size,
 275         lvbo_fill:      ofd_lvbo_fill
 276 };