lustre/mds/mds_reint.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  linux/mds/mds_reint.c
   5  *
   6  *  Lustre Metadata Server (mds) reintegration routines
   7  *
   8  *  Copyright (C) 2002  Cluster File Systems, Inc.
   9  *  author: Peter Braam <braam@clusterfs.com>
  10  *
  11  *  This code is issued under the GNU General Public License.
  12  *  See the file COPYING in this distribution
  13  *
  14  */
  15
  16 // XXX - add transaction sequence numbers
  17
  18 #define EXPORT_SYMTAB
  19
  20 #include <linux/version.h>
  21 #include <linux/module.h>
  22 #include <linux/fs.h>
  23 #include <linux/stat.h>
  24 #include <linux/locks.h>
  25 #include <linux/quotaops.h>
  26 #include <asm/unistd.h>
  27 #include <asm/uaccess.h>
  28
  29 #define DEBUG_SUBSYSTEM S_MDS
  30
  31 #include <linux/obd_support.h>
  32 #include <linux/obd_class.h>
  33 #include <linux/obd.h>
  34 #include <linux/lustre_lib.h>
  35 #include <linux/lustre_idl.h>
  36 #include <linux/lustre_mds.h>
  37 #include <linux/obd_class.h>
  38
  39 int mds_update_last_rcvd(struct mds_obd *mds, struct ptlrpc_request *req)
  40 {
  41         return 0;
  42 }
  43
  44 static int mds_reint_setattr(struct mds_update_record *rec,
  45                              struct ptlrpc_request *req)
  46 {
  47         struct mds_obd *mds = &req->rq_obd->u.mds;
  48         struct dentry *de;
  49         void *handle;
  50         int rc = 0;
  51
  52         de = mds_fid2dentry(mds, rec->ur_fid1, NULL);
  53         if (IS_ERR(de) || OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_SETATTR)) {
  54                 GOTO(out_setattr, rc = -ESTALE);
  55         }
  56
  57         CDEBUG(D_INODE, "ino %ld\n", de->d_inode->i_ino);
  58
  59         OBD_FAIL_WRITE(OBD_FAIL_MDS_REINT_SETATTR_WRITE,
  60                        de->d_inode->i_sb->s_dev);
  61
  62         handle = mds_fs_start(mds, de->d_inode, MDS_FSOP_SETATTR);
  63         if (!handle)
  64                 GOTO(out_setattr_de, rc = PTR_ERR(handle));
  65         rc = mds_fs_setattr(mds, de, handle, &rec->ur_iattr);
  66
  67         if (!rc)
  68                 rc = mds_update_last_rcvd(mds, req);
  69
  70         EXIT;
  71
  72         /* FIXME: keep rc intact */
  73         rc = mds_fs_commit(mds, de->d_inode, handle);
  74 out_setattr_de:
  75         l_dput(de);
  76 out_setattr:
  77         req->rq_status = rc;
  78         return(0);
  79 }
  80
  81 static int mds_reint_create(struct mds_update_record *rec,
  82                             struct ptlrpc_request *req)
  83 {
  84         struct dentry *de = NULL;
  85         struct mds_obd *mds = &req->rq_obd->u.mds;
  86         struct dentry *dchild = NULL;
  87         struct inode *dir;
  88         void *handle;
  89         int rc = 0, type = rec->ur_mode & S_IFMT;
  90         ENTRY;
  91
  92         de = mds_fid2dentry(mds, rec->ur_fid1, NULL);
  93         if (IS_ERR(de) || OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_CREATE)) {
  94                 LBUG();
  95                 GOTO(out_create_de, rc = -ESTALE);
  96         }
  97         dir = de->d_inode;
  98         CDEBUG(D_INODE, "ino %ld\n", dir->i_ino);
  99
 100         down(&dir->i_sem);
 101         dchild = lookup_one_len(rec->ur_name, de, rec->ur_namelen - 1);
 102         if (IS_ERR(dchild)) {
 103                 CERROR("child lookup error %ld\n", PTR_ERR(dchild));
 104                 up(&dir->i_sem);
 105                 LBUG();
 106                 GOTO(out_create_dchild, rc = -ESTALE);
 107         }
 108
 109         if (dchild->d_inode) {
 110                 CERROR("child exists (dir %ld, name %s)\n",
 111                        dir->i_ino, rec->ur_name);
 112                 LBUG();
 113                 GOTO(out_create_dchild, rc = -EEXIST);
 114         }
 115
 116         OBD_FAIL_WRITE(OBD_FAIL_MDS_REINT_CREATE_WRITE, dir->i_sb->s_dev);
 117
 118         switch (type) {
 119         case S_IFREG: {
 120                 handle = mds_fs_start(mds, dir, MDS_FSOP_CREATE);
 121                 if (!handle)
 122                         GOTO(out_create_dchild, PTR_ERR(handle));
 123                 rc = vfs_create(dir, dchild, rec->ur_mode);
 124                 EXIT;
 125                 break;
 126         }
 127         case S_IFDIR: {
 128                 handle = mds_fs_start(mds, dir, MDS_FSOP_MKDIR);
 129                 if (!handle)
 130                         GOTO(out_create_dchild, PTR_ERR(handle));
 131                 rc = vfs_mkdir(dir, dchild, rec->ur_mode);
 132                 EXIT;
 133                 break;
 134         }
 135         case S_IFLNK: {
 136                 handle = mds_fs_start(mds, dir, MDS_FSOP_SYMLINK);
 137                 if (!handle)
 138                         GOTO(out_create_dchild, PTR_ERR(handle));
 139                 rc = vfs_symlink(dir, dchild, rec->ur_tgt);
 140                 EXIT;
 141                 break;
 142         }
 143         case S_IFCHR:
 144         case S_IFBLK:
 145         case S_IFIFO:
 146         case S_IFSOCK: {
 147                 int rdev = rec->ur_id;
 148                 handle = mds_fs_start(mds, dir, MDS_FSOP_MKNOD);
 149                 if (!handle)
 150                         GOTO(out_create_dchild, PTR_ERR(handle));
 151                 rc = vfs_mknod(dir, dchild, rec->ur_mode, rdev);
 152                 EXIT;
 153                 break;
 154         }
 155         default:
 156                 CERROR("bad file type %d for create of %s\n",type,rec->ur_name);
 157                 GOTO(out_create_dchild, rc = -EINVAL);
 158         }
 159
 160         if (rc) {
 161                 CERROR("error during create: %d\n", rc);
 162                 LBUG();
 163                 GOTO(out_create_commit, rc);
 164         } else {
 165                 struct iattr iattr;
 166                 struct inode *inode = dchild->d_inode;
 167                 struct mds_body *body;
 168
 169                 if (type == S_IFREG) {
 170                         rc = mds_fs_set_objid(mds, inode, handle, rec->ur_id);
 171                         if (rc)
 172                                 CERROR("error %d setting objid for %ld\n",
 173                                        rc, inode->i_ino);
 174                 }
 175
 176                 iattr.ia_atime = rec->ur_time;
 177                 iattr.ia_ctime = rec->ur_time;
 178                 iattr.ia_mtime = rec->ur_time;
 179                 iattr.ia_uid = rec->ur_uid;
 180                 iattr.ia_gid = rec->ur_gid;
 181                 iattr.ia_valid = ATTR_UID | ATTR_GID | ATTR_ATIME |
 182                         ATTR_MTIME | ATTR_CTIME;
 183
 184                 rc = mds_fs_setattr(mds, dchild, handle, &iattr);
 185                 /* XXX should we abort here in case of error? */
 186
 187                 body = lustre_msg_buf(req->rq_repmsg, 0);
 188                 body->ino = inode->i_ino;
 189                 body->generation = inode->i_generation;
 190         }
 191
 192         if (!rc)
 193                 rc = mds_update_last_rcvd(mds, req);
 194
 195 out_create_commit:
 196         /* FIXME: keep rc intact */
 197         rc = mds_fs_commit(mds, dir, handle);
 198 out_create_dchild:
 199         l_dput(dchild);
 200         up(&dir->i_sem);
 201 out_create_de:
 202         l_dput(de);
 203         req->rq_status = rc;
 204         return 0;
 205 }
 206
 207 static int mds_reint_unlink(struct mds_update_record *rec,
 208                             struct ptlrpc_request *req)
 209 {
 210         struct dentry *de = NULL;
 211         struct dentry *dchild = NULL;
 212         struct mds_obd *mds = &req->rq_obd->u.mds;
 213         struct inode *dir, *inode;
 214         void *handle;
 215         int rc = 0;
 216         ENTRY;
 217
 218         de = mds_fid2dentry(mds, rec->ur_fid1, NULL);
 219         if (IS_ERR(de) || OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_UNLINK)) {
 220                 LBUG();
 221                 GOTO(out_unlink, rc = -ESTALE);
 222         }
 223         dir = de->d_inode;
 224         CDEBUG(D_INODE, "ino %ld\n", dir->i_ino);
 225
 226         down(&dir->i_sem);
 227         dchild = lookup_one_len(rec->ur_name, de, rec->ur_namelen - 1);
 228         if (IS_ERR(dchild)) {
 229                 CERROR("child lookup error %ld\n", PTR_ERR(dchild));
 230                 LBUG();
 231                 GOTO(out_unlink_de, rc = -ESTALE);
 232         }
 233
 234         inode = dchild->d_inode;
 235         if (!inode) {
 236                 CERROR("child doesn't exist (dir %ld, name %s\n",
 237                        dir->i_ino, rec->ur_name);
 238                 LBUG();
 239                 GOTO(out_unlink_dchild, rc = -ESTALE);
 240         }
 241
 242         if (inode->i_ino != rec->ur_fid2->id) {
 243                 CERROR("inode and FID ID do not match (%ld != %Ld)\n",
 244                        inode->i_ino, rec->ur_fid2->id);
 245                 LBUG();
 246                 GOTO(out_unlink_dchild, rc = -ESTALE);
 247         }
 248         if (inode->i_generation != rec->ur_fid2->generation) {
 249                 CERROR("inode and FID GENERATION do not match (%d != %d)\n",
 250                        inode->i_generation, rec->ur_fid2->generation);
 251                 LBUG();
 252                 GOTO(out_unlink_dchild, rc = -ESTALE);
 253         }
 254
 255         OBD_FAIL_WRITE(OBD_FAIL_MDS_REINT_UNLINK_WRITE, dir->i_sb->s_dev);
 256
 257         switch (dchild->d_inode->i_mode & S_IFMT) {
 258         case S_IFDIR:
 259                 handle = mds_fs_start(mds, dir, MDS_FSOP_RMDIR);
 260                 if (!handle)
 261                         GOTO(out_unlink_dchild, rc = PTR_ERR(handle));
 262                 rc = vfs_rmdir(dir, dchild);
 263                 break;
 264         default:
 265                 handle = mds_fs_start(mds, dir, MDS_FSOP_UNLINK);
 266                 if (!handle)
 267                         GOTO(out_unlink_dchild, rc = PTR_ERR(handle));
 268                 rc = vfs_unlink(dir, dchild);
 269                 break;
 270         }
 271
 272         if (!rc)
 273                 rc = mds_update_last_rcvd(mds, req);
 274         /* FIXME: keep rc intact */
 275         rc = mds_fs_commit(mds, dir, handle);
 276
 277         EXIT;
 278 out_unlink_dchild:
 279         l_dput(dchild);
 280 out_unlink_de:
 281         up(&dir->i_sem);
 282         l_dput(de);
 283 out_unlink:
 284         req->rq_status = rc;
 285         return 0;
 286 }
 287
 288 static int mds_reint_link(struct mds_update_record *rec,
 289                             struct ptlrpc_request *req)
 290 {
 291         struct dentry *de_src = NULL;
 292         struct dentry *de_tgt_dir = NULL;
 293         struct dentry *dchild = NULL;
 294         struct mds_obd *mds = &req->rq_obd->u.mds;
 295         void *handle;
 296         int rc = 0;
 297
 298         ENTRY;
 299         de_src = mds_fid2dentry(mds, rec->ur_fid1, NULL);
 300         if (IS_ERR(de_src) || OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_LINK)) {
 301                 GOTO(out_link, rc = -ESTALE);
 302         }
 303
 304         de_tgt_dir = mds_fid2dentry(mds, rec->ur_fid2, NULL);
 305         if (IS_ERR(de_tgt_dir)) {
 306                 GOTO(out_link_de_src, rc = -ESTALE);
 307         }
 308
 309         down(&de_tgt_dir->d_inode->i_sem);
 310         dchild = lookup_one_len(rec->ur_name, de_tgt_dir, rec->ur_namelen - 1);
 311         if (IS_ERR(dchild)) {
 312                 CERROR("child lookup error %ld\n", PTR_ERR(dchild));
 313                 GOTO(out_link_de_tgt_dir, rc = -ESTALE);
 314         }
 315
 316         if (dchild->d_inode) {
 317                 CERROR("child exists (dir %ld, name %s\n",
 318                        de_tgt_dir->d_inode->i_ino, rec->ur_name);
 319                 GOTO(out_link_dchild, rc = -EEXIST);
 320         }
 321
 322         OBD_FAIL_WRITE(OBD_FAIL_MDS_REINT_LINK_WRITE,
 323                        dchild->d_inode->i_sb->s_dev);
 324
 325         handle = mds_fs_start(mds, de_tgt_dir->d_inode, MDS_FSOP_LINK);
 326         if (!handle)
 327                 GOTO(out_link_dchild, rc = PTR_ERR(handle));
 328
 329         rc = vfs_link(de_src, de_tgt_dir->d_inode, dchild);
 330
 331         if (!rc)
 332                 rc = mds_update_last_rcvd(mds, req);
 333
 334         /* FIXME: keep rc intact */
 335         rc = mds_fs_commit(mds, de_tgt_dir->d_inode, handle);
 336         EXIT;
 337
 338 out_link_dchild:
 339         l_dput(dchild);
 340 out_link_de_tgt_dir:
 341         up(&de_tgt_dir->d_inode->i_sem);
 342         l_dput(de_tgt_dir);
 343 out_link_de_src:
 344         l_dput(de_src);
 345 out_link:
 346         req->rq_status = rc;
 347         return 0;
 348 }
 349
 350 static int mds_reint_rename(struct mds_update_record *rec,
 351                             struct ptlrpc_request *req)
 352 {
 353         struct dentry *de_srcdir = NULL;
 354         struct dentry *de_tgtdir = NULL;
 355         struct dentry *de_old = NULL;
 356         struct dentry *de_new = NULL;
 357         struct mds_obd *mds = &req->rq_obd->u.mds;
 358         void *handle;
 359         int rc = 0;
 360         ENTRY;
 361
 362         de_srcdir = mds_fid2dentry(mds, rec->ur_fid1, NULL);
 363         if (IS_ERR(de_srcdir)) {
 364                 GOTO(out_rename, rc = -ESTALE);
 365         }
 366
 367         de_tgtdir = mds_fid2dentry(mds, rec->ur_fid2, NULL);
 368         if (IS_ERR(de_tgtdir)) {
 369                 GOTO(out_rename_srcdir, rc = -ESTALE);
 370         }
 371
 372         de_old = lookup_one_len(rec->ur_name, de_srcdir, rec->ur_namelen - 1);
 373         if (IS_ERR(de_old)) {
 374                 CERROR("old child lookup error %ld\n", PTR_ERR(de_old));
 375                 GOTO(out_rename_tgtdir, rc = -ESTALE);
 376         }
 377
 378         de_new = lookup_one_len(rec->ur_tgt, de_tgtdir, rec->ur_tgtlen - 1);
 379         if (IS_ERR(de_new)) {
 380                 CERROR("new child lookup error %ld\n", PTR_ERR(de_new));
 381                 GOTO(out_rename_deold, rc = -ESTALE);
 382         }
 383
 384         OBD_FAIL_WRITE(OBD_FAIL_MDS_REINT_RENAME_WRITE,
 385                        de_srcdir->d_inode->i_sb->s_dev);
 386
 387         handle = mds_fs_start(mds, de_tgtdir->d_inode, MDS_FSOP_RENAME);
 388         if (!handle)
 389                 GOTO(out_rename_denew, rc = PTR_ERR(handle));
 390         rc = vfs_rename(de_srcdir->d_inode, de_old, de_tgtdir->d_inode, de_new);
 391
 392         if (!rc)
 393                 rc = mds_update_last_rcvd(mds, req);
 394
 395         /* FIXME: keep rc intact */
 396         rc = mds_fs_commit(mds, de_tgtdir->d_inode, handle);
 397         EXIT;
 398
 399 out_rename_denew:
 400         l_dput(de_new);
 401 out_rename_deold:
 402         l_dput(de_old);
 403 out_rename_tgtdir:
 404         l_dput(de_tgtdir);
 405 out_rename_srcdir:
 406         l_dput(de_srcdir);
 407 out_rename:
 408         req->rq_status = rc;
 409         return 0;
 410 }
 411
 412 typedef int (*mds_reinter)(struct mds_update_record *, struct ptlrpc_request*);
 413
 414 static mds_reinter reinters[REINT_MAX+1] = {
 415         [REINT_SETATTR]   mds_reint_setattr,
 416         [REINT_CREATE]    mds_reint_create,
 417         [REINT_UNLINK]    mds_reint_unlink,
 418         [REINT_LINK]      mds_reint_link,
 419         [REINT_RENAME]    mds_reint_rename,
 420 };
 421
 422 int mds_reint_rec(struct mds_update_record *rec, struct ptlrpc_request *req)
 423 {
 424         int rc, size = sizeof(struct mds_body);
 425
 426         if (rec->ur_opcode < 1 || rec->ur_opcode > REINT_MAX) {
 427                 CERROR("opcode %d not valid\n", rec->ur_opcode);
 428                 rc = req->rq_status = -EINVAL;
 429                 RETURN(rc);
 430         }
 431
 432         rc = lustre_pack_msg(1, &size, NULL, &req->rq_replen, &req->rq_repmsg);
 433         if (rc) {
 434                 CERROR("mds: out of memory\n");
 435                 rc = req->rq_status = -ENOMEM;
 436                 RETURN(rc);
 437         }
 438
 439         rc = reinters[rec->ur_opcode](rec, req);
 440         return rc;
 441 }