lustre/obdclass/linkea.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, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 021110-1307, USA
  20  *
  21  * GPL HEADER END
  22  */
  23 /*
  24  * Copyright (c) 2013, 2017, Intel Corporation.
  25  * Use is subject to license terms.
  26  *
  27  * Author: Di Wang <di.wang@intel.com>
  28  */
  29
  30 #include <obd.h>
  31 #include <lustre_linkea.h>
  32
  33 int linkea_data_new(struct linkea_data *ldata, struct lu_buf *buf)
  34 {
  35         ldata->ld_buf = lu_buf_check_and_alloc(buf, PAGE_SIZE);
  36         if (ldata->ld_buf->lb_buf == NULL)
  37                 return -ENOMEM;
  38         ldata->ld_leh = ldata->ld_buf->lb_buf;
  39         ldata->ld_leh->leh_magic = LINK_EA_MAGIC;
  40         ldata->ld_leh->leh_reccount = 0;
  41         ldata->ld_leh->leh_len = sizeof(struct link_ea_header);
  42         ldata->ld_leh->leh_overflow_time = 0;
  43         ldata->ld_leh->leh_padding = 0;
  44         return 0;
  45 }
  46 EXPORT_SYMBOL(linkea_data_new);
  47
  48 int linkea_init(struct linkea_data *ldata)
  49 {
  50         struct link_ea_header *leh;
  51
  52         LASSERT(ldata->ld_buf != NULL);
  53         leh = ldata->ld_buf->lb_buf;
  54         if (leh->leh_magic == __swab32(LINK_EA_MAGIC)) {
  55                 leh->leh_magic = LINK_EA_MAGIC;
  56                 leh->leh_reccount = __swab32(leh->leh_reccount);
  57                 leh->leh_len = __swab64(leh->leh_len);
  58                 leh->leh_overflow_time = __swab32(leh->leh_overflow_time);
  59                 leh->leh_padding = __swab32(leh->leh_padding);
  60                 /* individual entries are swabbed by linkea_entry_unpack() */
  61         }
  62
  63         if (leh->leh_magic != LINK_EA_MAGIC)
  64                 return -EINVAL;
  65
  66         if (leh->leh_reccount == 0 && leh->leh_overflow_time == 0)
  67                 return -ENODATA;
  68
  69         ldata->ld_leh = leh;
  70         return 0;
  71 }
  72 EXPORT_SYMBOL(linkea_init);
  73
  74 int linkea_init_with_rec(struct linkea_data *ldata)
  75 {
  76         int rc;
  77
  78         rc = linkea_init(ldata);
  79         if (!rc && ldata->ld_leh->leh_reccount == 0)
  80                 rc = -ENODATA;
  81
  82         return rc;
  83 }
  84 EXPORT_SYMBOL(linkea_init_with_rec);
  85
  86 /**
  87  * Pack a link_ea_entry.
  88  * All elements are stored as chars to avoid alignment issues.
  89  * Numbers are always big-endian
  90  * \retval record length
  91  */
  92 int linkea_entry_pack(struct link_ea_entry *lee, const struct lu_name *lname,
  93                       const struct lu_fid *pfid)
  94 {
  95         struct lu_fid   tmpfid;
  96         int             reclen;
  97
  98         tmpfid = *pfid;
  99         if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_MUL_REF))
 100                 tmpfid.f_oid--;
 101         if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_LINKEA_CRASH))
 102                 tmpfid.f_ver = ~0;
 103         fid_cpu_to_be(&tmpfid, &tmpfid);
 104         memcpy(&lee->lee_parent_fid, &tmpfid, sizeof(tmpfid));
 105         memcpy(lee->lee_name, lname->ln_name, lname->ln_namelen);
 106         reclen = sizeof(struct link_ea_entry) + lname->ln_namelen;
 107
 108         lee->lee_reclen[0] = (reclen >> 8) & 0xff;
 109         lee->lee_reclen[1] = reclen & 0xff;
 110         return reclen;
 111 }
 112 EXPORT_SYMBOL(linkea_entry_pack);
 113
 114 void linkea_entry_unpack(const struct link_ea_entry *lee, int *reclen,
 115                          struct lu_name *lname, struct lu_fid *pfid)
 116 {
 117         LASSERT(lee != NULL);
 118
 119         *reclen = (lee->lee_reclen[0] << 8) | lee->lee_reclen[1];
 120         memcpy(pfid, &lee->lee_parent_fid, sizeof(*pfid));
 121         fid_be_to_cpu(pfid, pfid);
 122         if (lname != NULL) {
 123                 lname->ln_name = lee->lee_name;
 124                 lname->ln_namelen = *reclen - sizeof(struct link_ea_entry);
 125         }
 126 }
 127 EXPORT_SYMBOL(linkea_entry_unpack);
 128
 129 /**
 130  * Add a record to the end of link ea buf
 131  **/
 132 int linkea_add_buf(struct linkea_data *ldata, const struct lu_name *lname,
 133                    const struct lu_fid *pfid)
 134 {
 135         struct link_ea_header *leh = ldata->ld_leh;
 136         int reclen;
 137
 138         LASSERT(leh != NULL);
 139
 140         if (lname == NULL || pfid == NULL)
 141                 return -EINVAL;
 142
 143         reclen = lname->ln_namelen + sizeof(struct link_ea_entry);
 144         if (unlikely(leh->leh_len + reclen > MAX_LINKEA_SIZE)) {
 145                 /* Use 32-bits to save the overflow time, although it will
 146                  * shrink the ktime_get_real_seconds() returned 64-bits value
 147                  * to 32-bits value, it is still quite large and can be used
 148                  * for about 140 years. That is enough.
 149                  */
 150                 leh->leh_overflow_time = ktime_get_real_seconds();
 151                 if (unlikely(leh->leh_overflow_time == 0))
 152                         leh->leh_overflow_time++;
 153
 154                 CDEBUG(D_INODE, "No enough space to hold linkea entry '"
 155                        DFID": %.*s' at %u\n", PFID(pfid), lname->ln_namelen,
 156                        lname->ln_name, leh->leh_overflow_time);
 157                 return 0;
 158         }
 159
 160         if (leh->leh_len + reclen > ldata->ld_buf->lb_len) {
 161                 if (lu_buf_check_and_grow(ldata->ld_buf,
 162                                           leh->leh_len + reclen) < 0)
 163                         return -ENOMEM;
 164
 165                 leh = ldata->ld_leh = ldata->ld_buf->lb_buf;
 166         }
 167
 168         ldata->ld_lee = ldata->ld_buf->lb_buf + leh->leh_len;
 169         ldata->ld_reclen = linkea_entry_pack(ldata->ld_lee, lname, pfid);
 170         leh->leh_len += ldata->ld_reclen;
 171         leh->leh_reccount++;
 172         CDEBUG(D_INODE, "New link_ea name '"DFID":%.*s' is added\n",
 173                PFID(pfid), lname->ln_namelen, lname->ln_name);
 174         return 0;
 175 }
 176 EXPORT_SYMBOL(linkea_add_buf);
 177
 178 /** Del the current record from the link ea buf */
 179 void linkea_del_buf(struct linkea_data *ldata, const struct lu_name *lname)
 180 {
 181         LASSERT(ldata->ld_leh != NULL && ldata->ld_lee != NULL);
 182         LASSERT(ldata->ld_leh->leh_reccount > 0);
 183
 184         ldata->ld_leh->leh_reccount--;
 185         ldata->ld_leh->leh_len -= ldata->ld_reclen;
 186         memmove(ldata->ld_lee, (char *)ldata->ld_lee + ldata->ld_reclen,
 187                 (char *)ldata->ld_leh + ldata->ld_leh->leh_len -
 188                 (char *)ldata->ld_lee);
 189         CDEBUG(D_INODE, "Old link_ea name '%.*s' is removed\n",
 190                lname->ln_namelen, lname->ln_name);
 191
 192         if ((char *)ldata->ld_lee >= ((char *)ldata->ld_leh +
 193                                       ldata->ld_leh->leh_len))
 194                 ldata->ld_lee = NULL;
 195 }
 196 EXPORT_SYMBOL(linkea_del_buf);
 197
 198 int linkea_links_new(struct linkea_data *ldata, struct lu_buf *buf,
 199                      const struct lu_name *cname, const struct lu_fid *pfid)
 200 {
 201         int rc;
 202
 203         rc = linkea_data_new(ldata, buf);
 204         if (!rc)
 205                 rc = linkea_add_buf(ldata, cname, pfid);
 206
 207         return rc;
 208 }
 209 EXPORT_SYMBOL(linkea_links_new);
 210
 211 /**
 212  * Mark the linkEA as overflow with current timestamp,
 213  * and remove the last linkEA entry.
 214  *
 215  * Return the new linkEA size.
 216  */
 217 int linkea_overflow_shrink(struct linkea_data *ldata)
 218 {
 219         struct link_ea_header *leh;
 220         struct lu_name tname;
 221         struct lu_fid tfid;
 222         int count;
 223
 224         leh = ldata->ld_leh = ldata->ld_buf->lb_buf;
 225         if (leh->leh_magic == __swab32(LINK_EA_MAGIC)) {
 226                 leh->leh_magic = LINK_EA_MAGIC;
 227                 leh->leh_reccount = __swab32(leh->leh_reccount);
 228                 leh->leh_overflow_time = __swab32(leh->leh_overflow_time);
 229                 leh->leh_padding = __swab32(leh->leh_padding);
 230         }
 231
 232         LASSERT(leh->leh_reccount > 0);
 233
 234         leh->leh_len = sizeof(struct link_ea_header);
 235         leh->leh_reccount--;
 236         if (unlikely(leh->leh_reccount == 0))
 237                 return 0;
 238
 239         leh->leh_overflow_time = ktime_get_real_seconds();
 240         if (unlikely(leh->leh_overflow_time == 0))
 241                 leh->leh_overflow_time++;
 242         ldata->ld_reclen = 0;
 243         ldata->ld_lee = (struct link_ea_entry *)(leh + 1);
 244         for (count = 0; count < leh->leh_reccount; count++) {
 245                 linkea_entry_unpack(ldata->ld_lee, &ldata->ld_reclen,
 246                                     &tname, &tfid);
 247                 leh->leh_len += ldata->ld_reclen;
 248                 ldata->ld_lee = (struct link_ea_entry *)((char *)ldata->ld_lee +
 249                                                          ldata->ld_reclen);
 250         }
 251
 252         linkea_entry_unpack(ldata->ld_lee, &ldata->ld_reclen, &tname, &tfid);
 253         CDEBUG(D_INODE, "No enough space to hold the last linkea entry '"
 254                DFID": %.*s', shrink it, left %d linkea entries, size %llu\n",
 255                PFID(&tfid), tname.ln_namelen, tname.ln_name,
 256                leh->leh_reccount, leh->leh_len);
 257
 258         return leh->leh_len;
 259 }
 260 EXPORT_SYMBOL(linkea_overflow_shrink);
 261
 262 /**
 263  * Check if such a link exists in linkEA.
 264  *
 265  * \param ldata link data the search to be done on
 266  * \param lname name in the parent's directory entry pointing to this object
 267  * \param pfid parent fid the link to be found for
 268  *
 269  * \retval   0 success
 270  * \retval -ENOENT link does not exist
 271  * \retval -ve on error
 272  */
 273 int linkea_links_find(struct linkea_data *ldata, const struct lu_name *lname,
 274                       const struct lu_fid  *pfid)
 275 {
 276         struct lu_name tmpname;
 277         struct lu_fid  tmpfid;
 278         int count;
 279
 280         LASSERT(ldata->ld_leh != NULL);
 281
 282         /* link #0, if leh_reccount == 0 we skip the loop and return -ENOENT */
 283         if (likely(ldata->ld_leh->leh_reccount > 0))
 284                 ldata->ld_lee = (struct link_ea_entry *)(ldata->ld_leh + 1);
 285
 286         for (count = 0; count < ldata->ld_leh->leh_reccount; count++) {
 287                 linkea_entry_unpack(ldata->ld_lee, &ldata->ld_reclen,
 288                                     &tmpname, &tmpfid);
 289                 if (tmpname.ln_namelen == lname->ln_namelen &&
 290                     lu_fid_eq(&tmpfid, pfid) &&
 291                     (strncmp(tmpname.ln_name, lname->ln_name,
 292                              tmpname.ln_namelen) == 0))
 293                         break;
 294                 ldata->ld_lee = (struct link_ea_entry *)((char *)ldata->ld_lee +
 295                                                          ldata->ld_reclen);
 296         }
 297
 298         if (count == ldata->ld_leh->leh_reccount) {
 299                 CDEBUG(D_INODE, "Old link_ea name '%.*s' not found\n",
 300                        lname->ln_namelen, lname->ln_name);
 301                 ldata->ld_lee = NULL;
 302                 ldata->ld_reclen = 0;
 303                 return -ENOENT;
 304         }
 305         return 0;
 306 }
 307 EXPORT_SYMBOL(linkea_links_find);