lustre/osd-ldiskfs/osd_oi.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) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 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/osd/osd_oi.c
  37  *
  38  * Object Index.
  39  *
  40  * Author: Nikita Danilov <nikita@clusterfs.com>
  41  */
  42
  43 /*
  44  * oi uses two mechanisms to implement fid->cookie mapping:
  45  *
  46  *     - persistent index, where cookie is a record and fid is a key, and
  47  *
  48  *     - algorithmic mapping for "igif" fids.
  49  *
  50  */
  51
  52 #ifndef EXPORT_SYMTAB
  53 # define EXPORT_SYMTAB
  54 #endif
  55 #define DEBUG_SUBSYSTEM S_MDS
  56
  57 #include <linux/module.h>
  58
  59 /* LUSTRE_VERSION_CODE */
  60 #include <lustre_ver.h>
  61 /*
  62  * struct OBD_{ALLOC,FREE}*()
  63  * OBD_FAIL_CHECK
  64  */
  65 #include <obd.h>
  66 #include <obd_support.h>
  67
  68 /* fid_cpu_to_be() */
  69 #include <lustre_fid.h>
  70
  71 #include "osd_oi.h"
  72 /* osd_lookup(), struct osd_thread_info */
  73 #include "osd_internal.h"
  74 #include "osd_igif.h"
  75 #include "dt_object.h"
  76
  77 #define OSD_OI_FID_NR         (1UL << OSD_OI_FID_OID_BITS)
  78 #define OSD_OI_FID_NR_MAX     (1UL << OSD_OI_FID_OID_BITS_MAX)
  79
  80 static unsigned int osd_oi_count = OSD_OI_FID_NR;
  81 CFS_MODULE_PARM(osd_oi_count, "i", int, 0444,
  82                 "Number of Object Index containers to be created, "
  83                 "it's only valid for new filesystem.");
  84
  85 /** to serialize concurrent OI index initialization */
  86 static cfs_mutex_t oi_init_lock;
  87
  88 static struct dt_index_features oi_feat = {
  89         .dif_flags       = DT_IND_UPDATE,
  90         .dif_recsize_min = sizeof(struct osd_inode_id),
  91         .dif_recsize_max = sizeof(struct osd_inode_id),
  92         .dif_ptrsize     = 4
  93 };
  94
  95 #define OSD_OI_NAME_BASE        "oi.16"
  96
  97 static void osd_oi_table_put(struct osd_thread_info *info,
  98                              struct osd_oi **oi_table, unsigned oi_count)
  99 {
 100         struct iam_container *bag;
 101         int                   i;
 102
 103         for (i = 0; i < oi_count; i++) {
 104                 LASSERT(oi_table[i] != NULL);
 105                 LASSERT(oi_table[i]->oi_inode != NULL);
 106
 107                 bag = &(oi_table[i]->oi_dir.od_container);
 108                 if (bag->ic_object == oi_table[i]->oi_inode)
 109                         iam_container_fini(bag);
 110                 iput(oi_table[i]->oi_inode);
 111                 oi_table[i]->oi_inode = NULL;
 112                 OBD_FREE_PTR(oi_table[i]);
 113         }
 114 }
 115
 116 static int osd_oi_index_create_one(struct osd_thread_info *info,
 117                                    struct osd_device *osd, const char *name,
 118                                    struct dt_index_features *feat)
 119 {
 120         const struct lu_env             *env = info->oti_env;
 121         struct osd_inode_id             *id  = &info->oti_id;
 122         struct buffer_head              *bh;
 123         struct inode                    *inode;
 124         struct ldiskfs_dir_entry_2      *de;
 125         struct dentry                   *dentry;
 126         struct inode                    *dir;
 127         handle_t                        *jh;
 128         int                              rc;
 129
 130         dentry = osd_child_dentry_by_inode(env, osd_sb(osd)->s_root->d_inode,
 131                                            name, strlen(name));
 132         dir = osd_sb(osd)->s_root->d_inode;
 133         bh = osd_ldiskfs_find_entry(dir, dentry, &de, NULL);
 134         if (bh) {
 135                 brelse(bh);
 136
 137                 id->oii_ino = le32_to_cpu(de->inode);
 138                 id->oii_gen = OSD_OII_NOGEN;
 139
 140                 inode = osd_iget(info, osd, id);
 141                 if (!IS_ERR(inode)) {
 142                         iput(inode);
 143                         RETURN(-EEXIST);
 144                 }
 145                 RETURN(PTR_ERR(inode));
 146         }
 147
 148         jh = ldiskfs_journal_start_sb(osd_sb(osd), 100);
 149         LASSERT(!IS_ERR(jh));
 150
 151         inode = ldiskfs_create_inode(jh, osd_sb(osd)->s_root->d_inode,
 152                                      (S_IFREG | S_IRUGO | S_IWUSR));
 153         LASSERT(!IS_ERR(inode));
 154
 155         if (feat->dif_flags & DT_IND_VARKEY)
 156                 rc = iam_lvar_create(inode, feat->dif_keysize_max,
 157                                      feat->dif_ptrsize, feat->dif_recsize_max,
 158                                      jh);
 159         else
 160                 rc = iam_lfix_create(inode, feat->dif_keysize_max,
 161                                      feat->dif_ptrsize, feat->dif_recsize_max,
 162                                      jh);
 163
 164         dentry = osd_child_dentry_by_inode(env, osd_sb(osd)->s_root->d_inode,
 165                                            name, strlen(name));
 166         rc = osd_ldiskfs_add_entry(jh, dentry, inode, NULL);
 167         LASSERT(rc == 0);
 168
 169         ldiskfs_journal_stop(jh);
 170         iput(inode);
 171
 172         return rc;
 173 }
 174
 175 static struct inode *osd_oi_index_open(struct osd_thread_info *info,
 176                                        struct osd_device *osd,
 177                                        const char *name,
 178                                        struct dt_index_features *f,
 179                                        bool create)
 180 {
 181         struct dentry *dentry;
 182         struct inode  *inode;
 183         int            rc;
 184
 185         dentry = ll_lookup_one_len(name, osd_sb(osd)->s_root, strlen(name));
 186         if (IS_ERR(dentry))
 187                 return (void *) dentry;
 188
 189         if (dentry->d_inode) {
 190                 LASSERT(!is_bad_inode(dentry->d_inode));
 191                 inode = dentry->d_inode;
 192                 atomic_inc(&inode->i_count);
 193                 dput(dentry);
 194                 return inode;
 195         }
 196
 197         /* create */
 198         dput(dentry);
 199         shrink_dcache_parent(osd_sb(osd)->s_root);
 200         if (!create)
 201                 return ERR_PTR(-ENOENT);
 202
 203         rc = osd_oi_index_create_one(info, osd, name, f);
 204         if (rc)
 205                 RETURN(ERR_PTR(rc));
 206
 207         dentry = ll_lookup_one_len(name, osd_sb(osd)->s_root, strlen(name));
 208         if (IS_ERR(dentry))
 209                 return (void *) dentry;
 210
 211         if (dentry->d_inode) {
 212                 LASSERT(!is_bad_inode(dentry->d_inode));
 213                 inode = dentry->d_inode;
 214                 atomic_inc(&inode->i_count);
 215                 dput(dentry);
 216                 return inode;
 217         }
 218
 219         return ERR_PTR(-ENOENT);
 220 }
 221
 222 /**
 223  * Open an OI(Ojbect Index) container.
 224  *
 225  * \param       name    Name of OI container
 226  * \param       objp    Pointer of returned OI
 227  *
 228  * \retval      0       success
 229  * \retval      -ve     failure
 230  */
 231 static int osd_oi_open(struct osd_thread_info *info, struct osd_device *osd,
 232                        char *name, struct osd_oi **oi_slot, bool create)
 233 {
 234         struct osd_directory *dir;
 235         struct iam_container *bag;
 236         struct inode         *inode;
 237         struct osd_oi        *oi;
 238         int                   rc;
 239
 240         ENTRY;
 241
 242         oi_feat.dif_keysize_min = sizeof(struct lu_fid);
 243         oi_feat.dif_keysize_max = sizeof(struct lu_fid);
 244
 245         inode = osd_oi_index_open(info, osd, name, &oi_feat, create);
 246         if (IS_ERR(inode))
 247                 RETURN(PTR_ERR(inode));
 248
 249         OBD_ALLOC_PTR(oi);
 250         if (oi == NULL)
 251                 GOTO(out_inode, rc = -ENOMEM);
 252
 253         oi->oi_inode = inode;
 254         dir = &oi->oi_dir;
 255
 256         bag = &dir->od_container;
 257         rc = iam_container_init(bag, &dir->od_descr, inode);
 258         if (rc < 0)
 259                 GOTO(out_free, rc);
 260
 261         rc = iam_container_setup(bag);
 262         if (rc < 0)
 263                 GOTO(out_container, rc);
 264
 265         *oi_slot = oi;
 266         RETURN(0);
 267
 268 out_container:
 269         iam_container_fini(bag);
 270 out_free:
 271         OBD_FREE_PTR(oi);
 272 out_inode:
 273         iput(inode);
 274         return rc;
 275 }
 276
 277 /**
 278  * Open OI(Object Index) table.
 279  * If \a oi_count is zero, which means caller doesn't know how many OIs there
 280  * will be, this function can either return 0 for new filesystem, or number
 281  * of OIs on existed filesystem.
 282  *
 283  * If \a oi_count is non-zero, which means caller does know number of OIs on
 284  * filesystem, this function should return the exactly same number on
 285  * success, or error code in failure.
 286  *
 287  * \param     oi_count  Number of expected OI containers
 288  * \param     create    Create OIs if doesn't exist
 289  *
 290  * \retval    +ve       number of opened OI containers
 291  * \retval      0       no OI containers found
 292  * \retval    -ve       failure
 293  */
 294 static int
 295 osd_oi_table_open(struct osd_thread_info *info, struct osd_device *osd,
 296                   struct osd_oi **oi_table, unsigned oi_count, bool create)
 297 {
 298         struct dt_device *dev = &osd->od_dt_dev;
 299         int               count = 0;
 300         int               rc = 0;
 301         int               i;
 302
 303         /* NB: oi_count != 0 means that we have already created/known all OIs
 304          * and have known exact number of OIs. */
 305         LASSERT(oi_count <= OSD_OI_FID_NR_MAX);
 306
 307         for (i = 0; i < (oi_count != 0 ? oi_count : OSD_OI_FID_NR_MAX); i++) {
 308                 char name[12];
 309
 310                 sprintf(name, "%s.%d", OSD_OI_NAME_BASE, i);
 311                 rc = osd_oi_open(info, osd, name, &oi_table[i], create);
 312                 if (rc == 0) {
 313                         count++;
 314                         continue;
 315                 }
 316
 317                 if (rc == -ENOENT && oi_count == 0)
 318                         return count;
 319
 320                 CERROR("%s: can't open %s: rc = %d\n",
 321                        dev->dd_lu_dev.ld_obd->obd_name, name, rc);
 322                 if (oi_count > 0) {
 323                         CERROR("%s: expect to open total %d OI files.\n",
 324                                dev->dd_lu_dev.ld_obd->obd_name, oi_count);
 325                 }
 326                 break;
 327         }
 328
 329         if (rc < 0) {
 330                 osd_oi_table_put(info, oi_table, count);
 331                 return rc;
 332         }
 333
 334         return count;
 335 }
 336
 337 int osd_oi_init(struct osd_thread_info *info, struct osd_device *osd)
 338 {
 339         struct dt_device *dev = &osd->od_dt_dev;
 340         struct osd_oi   **oi;
 341         int               rc;
 342
 343         OBD_ALLOC(oi, sizeof(*oi) * OSD_OI_FID_NR_MAX);
 344         if (oi == NULL)
 345                 return -ENOMEM;
 346
 347         cfs_mutex_lock(&oi_init_lock);
 348         /* try to open existing multiple OIs first */
 349         rc = osd_oi_table_open(info, osd, oi, 0, false);
 350         if (rc != 0)
 351                 goto out;
 352
 353         /* if previous failed then try found single OI from old filesystem */
 354         rc = osd_oi_open(info, osd, OSD_OI_NAME_BASE, &oi[0], false);
 355         if (rc == 0) { /* found single OI from old filesystem */
 356                 rc = 1;
 357                 goto out;
 358         } else if (rc != -ENOENT) {
 359                 CERROR("%s: can't open %s: rc = %d\n",
 360                        dev->dd_lu_dev.ld_obd->obd_name, OSD_OI_NAME_BASE, rc);
 361                 goto out;
 362         }
 363
 364         /* No OIs exist, new filesystem, create OI objects */
 365         rc = osd_oi_table_open(info, osd, oi, osd_oi_count, true);
 366         LASSERT(ergo(rc >= 0, rc == osd_oi_count));
 367 out:
 368         if (rc < 0) {
 369                 OBD_FREE(oi, sizeof(*oi) * OSD_OI_FID_NR_MAX);
 370         } else {
 371                 LASSERT((rc & (rc - 1)) == 0);
 372                 osd->od_oi_table = oi;
 373                 osd->od_oi_count = rc;
 374                 rc = 0;
 375         }
 376
 377         cfs_mutex_unlock(&oi_init_lock);
 378         return rc;
 379 }
 380
 381 void osd_oi_fini(struct osd_thread_info *info, struct osd_device *osd)
 382 {
 383         osd_oi_table_put(info, osd->od_oi_table, osd->od_oi_count);
 384
 385         OBD_FREE(osd->od_oi_table,
 386                  sizeof(*(osd->od_oi_table)) * OSD_OI_FID_NR_MAX);
 387         osd->od_oi_table = NULL;
 388 }
 389
 390 static inline int fid_is_fs_root(const struct lu_fid *fid)
 391 {
 392         /* Map root inode to special local object FID */
 393         return (unlikely(fid_seq(fid) == FID_SEQ_LOCAL_FILE &&
 394                          fid_oid(fid) == OSD_FS_ROOT_OID));
 395 }
 396
 397 static int osd_oi_iam_lookup(struct osd_thread_info *oti,
 398                              struct osd_oi *oi, struct dt_rec *rec,
 399                              const struct dt_key *key)
 400 {
 401         struct iam_container  *bag;
 402         struct iam_iterator   *it = &oti->oti_idx_it;
 403         struct iam_rec        *iam_rec;
 404         struct iam_path_descr *ipd;
 405         int                    rc;
 406         ENTRY;
 407
 408         LASSERT(oi);
 409         LASSERT(oi->oi_inode);
 410
 411         bag = &oi->oi_dir.od_container;
 412         ipd = osd_idx_ipd_get(oti->oti_env, bag);
 413         if (IS_ERR(ipd))
 414                 RETURN(-ENOMEM);
 415
 416         /* got ipd now we can start iterator. */
 417         iam_it_init(it, bag, 0, ipd);
 418
 419         rc = iam_it_get(it, (struct iam_key *)key);
 420         if (rc >= 0) {
 421                 if (S_ISDIR(oi->oi_inode->i_mode))
 422                         iam_rec = (struct iam_rec *)oti->oti_ldp;
 423                 else
 424                         iam_rec = (struct iam_rec *)rec;
 425
 426                 iam_reccpy(&it->ii_path.ip_leaf, (struct iam_rec *)iam_rec);
 427                 if (S_ISDIR(oi->oi_inode->i_mode))
 428                         osd_fid_unpack((struct lu_fid *)rec,
 429                                        (struct osd_fid_pack *)iam_rec);
 430         }
 431         iam_it_put(it);
 432         iam_it_fini(it);
 433         osd_ipd_put(oti->oti_env, bag, ipd);
 434
 435         LINVRNT(osd_invariant(obj));
 436
 437         RETURN(rc);
 438 }
 439
 440 int osd_oi_lookup(struct osd_thread_info *info, struct osd_device *osd,
 441                   const struct lu_fid *fid, struct osd_inode_id *id)
 442 {
 443         struct lu_fid       *oi_fid = &info->oti_fid;
 444         const struct dt_key *key;
 445         int                  rc = 0;
 446
 447         if (fid_is_idif(fid) || fid_seq(fid) == FID_SEQ_LLOG) {
 448                 /* old OSD obj id */
 449                 rc = osd_compat_objid_lookup(info, osd, fid, id);
 450         } else if (fid_is_igif(fid)) {
 451                 lu_igif_to_id(fid, id);
 452                 rc = 0;
 453         } else if (fid_is_fs_root(fid)) {
 454                 struct inode *inode = osd_sb(osd)->s_root->d_inode;
 455
 456                 id->oii_ino = inode->i_ino;
 457                 id->oii_gen = inode->i_generation;
 458         } else {
 459                 if (unlikely(fid_seq(fid) == FID_SEQ_LOCAL_FILE))
 460                         return osd_compat_spec_lookup(info, osd, fid, id);
 461
 462                 fid_cpu_to_be(oi_fid, fid);
 463                 key = (struct dt_key *)oi_fid;
 464
 465                 rc = osd_oi_iam_lookup(info, osd_fid2oi(osd, fid),
 466                                        (struct dt_rec *)id, key);
 467
 468                 if (rc > 0) {
 469                         id->oii_ino = be32_to_cpu(id->oii_ino);
 470                         id->oii_gen = be32_to_cpu(id->oii_gen);
 471                         rc = 0;
 472                 } else if (rc == 0) {
 473                         rc = -ENOENT;
 474                 }
 475         }
 476         return rc;
 477 }
 478
 479 static int osd_oi_iam_insert(struct osd_thread_info *oti, struct osd_oi *oi,
 480                              const struct dt_rec *rec, const struct dt_key *key,
 481                              struct thandle *th, int ignore_quota)
 482 {
 483         struct iam_container  *bag;
 484         struct iam_rec        *iam_rec = (struct iam_rec *)oti->oti_ldp;
 485         struct iam_path_descr *ipd;
 486         struct osd_thandle    *oh;
 487         int                    rc;
 488 #ifdef HAVE_QUOTA_SUPPORT
 489         cfs_cap_t              save    = cfs_curproc_cap_pack();
 490 #endif
 491         ENTRY;
 492
 493         LASSERT(oi);
 494         LASSERT(oi->oi_inode);
 495
 496         bag = &oi->oi_dir.od_container;
 497         ipd = osd_idx_ipd_get(oti->oti_env, bag);
 498         if (unlikely(ipd == NULL))
 499                 RETURN(-ENOMEM);
 500
 501         oh = container_of0(th, struct osd_thandle, ot_super);
 502         LASSERT(oh->ot_handle != NULL);
 503         LASSERT(oh->ot_handle->h_transaction != NULL);
 504 #ifdef HAVE_QUOTA_SUPPORT
 505         if (ignore_quota)
 506                 cfs_cap_raise(CFS_CAP_SYS_RESOURCE);
 507         else
 508                 cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
 509 #endif
 510         if (S_ISDIR(oi->oi_inode->i_mode))
 511                 osd_fid_pack((struct osd_fid_pack *)iam_rec, rec,
 512                              &oti->oti_fid);
 513         else
 514                 iam_rec = (struct iam_rec *) rec;
 515         rc = iam_insert(oh->ot_handle, bag, (const struct iam_key *)key,
 516                         iam_rec, ipd);
 517 #ifdef HAVE_QUOTA_SUPPORT
 518         cfs_curproc_cap_unpack(save);
 519 #endif
 520         osd_ipd_put(oti->oti_env, bag, ipd);
 521         LINVRNT(osd_invariant(obj));
 522         RETURN(rc);
 523 }
 524
 525 int osd_oi_insert(struct osd_thread_info *info, struct osd_device *osd,
 526                   const struct lu_fid *fid, const struct osd_inode_id *id0,
 527                   struct thandle *th, int ignore_quota)
 528 {
 529         struct lu_fid       *oi_fid = &info->oti_fid;
 530         struct osd_inode_id *id;
 531         const struct dt_key *key;
 532
 533         if (fid_is_igif(fid) || unlikely(fid_seq(fid) == FID_SEQ_DOT_LUSTRE))
 534                 return 0;
 535
 536         if (fid_is_idif(fid) || fid_seq(fid) == FID_SEQ_LLOG)
 537                 return osd_compat_objid_insert(info, osd, fid, id0, th);
 538
 539         /* Server mount should not depends on OI files */
 540         if (unlikely(fid_seq(fid) == FID_SEQ_LOCAL_FILE))
 541                 return osd_compat_spec_insert(info, osd, fid, id0, th);
 542
 543         fid_cpu_to_be(oi_fid, fid);
 544         key = (struct dt_key *)oi_fid;
 545
 546         id  = &info->oti_id;
 547         id->oii_ino = cpu_to_be32(id0->oii_ino);
 548         id->oii_gen = cpu_to_be32(id0->oii_gen);
 549
 550         return osd_oi_iam_insert(info, osd_fid2oi(osd, fid),
 551                                  (struct dt_rec *)id, key, th, ignore_quota);
 552 }
 553
 554 static int osd_oi_iam_delete(struct osd_thread_info *oti, struct osd_oi *oi,
 555                              const struct dt_key *key, struct thandle *handle)
 556 {
 557         struct iam_container  *bag;
 558         struct iam_path_descr *ipd;
 559         struct osd_thandle    *oh;
 560         int                    rc;
 561         ENTRY;
 562
 563         LASSERT(oi);
 564
 565         bag = &oi->oi_dir.od_container;
 566         ipd = osd_idx_ipd_get(oti->oti_env, bag);
 567         if (unlikely(ipd == NULL))
 568                 RETURN(-ENOMEM);
 569
 570         oh = container_of0(handle, struct osd_thandle, ot_super);
 571         LASSERT(oh->ot_handle != NULL);
 572         LASSERT(oh->ot_handle->h_transaction != NULL);
 573
 574         rc = iam_delete(oh->ot_handle, bag, (const struct iam_key *)key, ipd);
 575         osd_ipd_put(oti->oti_env, bag, ipd);
 576         LINVRNT(osd_invariant(obj));
 577         RETURN(rc);
 578 }
 579
 580 int osd_oi_delete(struct osd_thread_info *info,
 581                   struct osd_device *osd, const struct lu_fid *fid,
 582                   struct thandle *th)
 583 {
 584         struct lu_fid       *oi_fid = &info->oti_fid;
 585         const struct dt_key *key;
 586
 587         LASSERT(fid_seq(fid) != FID_SEQ_LOCAL_FILE);
 588
 589         if (fid_is_idif(fid) || fid_seq(fid) == FID_SEQ_LLOG)
 590                 return osd_compat_objid_delete(info, osd, fid, th);
 591
 592         fid_cpu_to_be(oi_fid, fid);
 593         key = (struct dt_key *)oi_fid;
 594
 595         return osd_oi_iam_delete(info, osd_fid2oi(osd, fid), key, th);
 596 }
 597
 598 int osd_oi_mod_init()
 599 {
 600         if (osd_oi_count == 0 || osd_oi_count > OSD_OI_FID_NR_MAX)
 601                 osd_oi_count = OSD_OI_FID_NR;
 602
 603         if ((osd_oi_count & (osd_oi_count - 1)) != 0) {
 604                 LCONSOLE_WARN("Round up oi_count %d to power2 %d\n",
 605                               osd_oi_count, size_roundup_power2(osd_oi_count));
 606                 osd_oi_count = size_roundup_power2(osd_oi_count);
 607         }
 608
 609         cfs_mutex_init(&oi_init_lock);
 610         return 0;
 611 }