Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/fs/intermezzo/kml_reint.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- 2 * vim:expandtab:shiftwidth=8:tabstop=8: 3 * 4 * Copyright (C) 2001 Cluster File Systems, Inc. <braam@clusterfs.com> 5 * 6 * This file is part of InterMezzo, http://www.inter-mezzo.org. 7 * 8 * InterMezzo is free software; you can redistribute it and/or 9 * modify it under the terms of version 2 of the GNU General Public 10 * License as published by the Free Software Foundation. 11 * 12 * InterMezzo is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with InterMezzo; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * 21 * Reintegration of KML records 22 * 23 */ 24 25 #define __NO_VERSION__ 26 #include <linux/module.h> 27 #include <linux/errno.h> 28 #include <linux/fs.h> 29 #include <linux/kernel.h> 30 #include <linux/major.h> 31 #include <linux/slab.h> 32 #include <linux/vmalloc.h> 33 #include <linux/mm.h> 34 #include <asm/uaccess.h> 35 #include <asm/pgtable.h> 36 #include <asm/mmu_context.h> 37 #include <linux/intermezzo_fs.h> 38 #include <linux/intermezzo_psdev.h> 39 40 static void kmlreint_pre_secure(struct kml_rec *rec, struct file *dir, 41 struct run_ctxt *saved) 42 { 43 struct run_ctxt ctxt; 44 struct presto_dentry_data *dd = presto_d2d(dir->f_dentry); 45 int i; 46 47 ctxt.fsuid = rec->prefix.hdr->fsuid; 48 ctxt.fsgid = rec->prefix.hdr->fsgid; 49 ctxt.fs = KERNEL_DS; 50 ctxt.pwd = dd->dd_fset->fset_dentry; 51 ctxt.pwdmnt = dd->dd_fset->fset_mnt; 52 53 ctxt.root = ctxt.pwd; 54 ctxt.rootmnt = ctxt.pwdmnt; 55 if (rec->prefix.hdr->ngroups > 0) { 56 ctxt.ngroups = rec->prefix.hdr->ngroups; 57 for (i = 0; i< ctxt.ngroups; i++) 58 ctxt.groups[i] = rec->prefix.groups[i]; 59 } else 60 ctxt.ngroups = 0; 61 62 push_ctxt(saved, &ctxt); 63 } 64 65 66 /* Append two strings in a less-retarded fashion. */ 67 static char * path_join(char *p1, int p1len, char *p2, int p2len) 68 { 69 int size = p1len + p2len + 2; /* possibly one extra /, one NULL */ 70 char *path; 71 72 path = kmalloc(size, GFP_KERNEL); 73 if (path == NULL) 74 return NULL; 75 76 memcpy(path, p1, p1len); 77 if (path[p1len - 1] != '/') { 78 path[p1len] = '/'; 79 p1len++; 80 } 81 memcpy(path + p1len, p2, p2len); 82 path[p1len + p2len] = '\0'; 83 84 return path; 85 } 86 87 static inline int kml_recno_equal(struct kml_rec *rec, 88 struct presto_file_set *fset) 89 { 90 return (rec->suffix->recno == fset->fset_lento_recno + 1); 91 } 92 93 static inline int version_equal(struct presto_version *a, struct inode *inode) 94 { 95 if (a == NULL) 96 return 1; 97 98 if (inode == NULL) { 99 CERROR("InterMezzo: NULL inode in version_equal()\n"); 100 return 0; 101 } 102 103 if (inode->i_mtime == a->pv_mtime && 104 (S_ISDIR(inode->i_mode) || inode->i_size == a->pv_size)) 105 return 1; 106 107 return 0; 108 } 109 110 static int reint_close(struct kml_rec *rec, struct file *file, 111 struct lento_vfs_context *given_info) 112 { 113 struct run_ctxt saved_ctxt; 114 int error; 115 struct presto_file_set *fset; 116 struct lento_vfs_context info; 117 ENTRY; 118 119 memcpy(&info, given_info, sizeof(*given_info)); 120 121 122 CDEBUG (D_KML, "=====REINT_CLOSE::%s\n", rec->path); 123 124 fset = presto_fset(file->f_dentry); 125 if (fset->fset_flags & FSET_DATA_ON_DEMAND) { 126 struct iattr iattr; 127 128 iattr.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_SIZE; 129 iattr.ia_mtime = (time_t)rec->new_objectv->pv_mtime; 130 iattr.ia_ctime = (time_t)rec->new_objectv->pv_ctime; 131 iattr.ia_size = (time_t)rec->new_objectv->pv_size; 132 133 /* no kml record, but update last rcvd */ 134 /* save fileid in dentry for later backfetch */ 135 info.flags |= LENTO_FL_EXPECT | LENTO_FL_SET_DDFILEID; 136 info.remote_ino = rec->ino; 137 info.remote_generation = rec->generation; 138 info.flags &= ~LENTO_FL_KML; 139 kmlreint_pre_secure(rec, file, &saved_ctxt); 140 error = lento_setattr(rec->path, &iattr, &info); 141 pop_ctxt(&saved_ctxt); 142 143 presto_d2d(file->f_dentry)->dd_flags &= ~PRESTO_DATA; 144 } else { 145 int minor = presto_f2m(fset); 146 147 info.updated_time = rec->new_objectv->pv_mtime; 148 memcpy(&info.remote_version, rec->old_objectv, 149 sizeof(*rec->old_objectv)); 150 info.remote_ino = rec->ino; 151 info.remote_generation = rec->generation; 152 error = izo_upc_backfetch(minor, rec->path, fset->fset_name, 153 &info); 154 if (error) { 155 CERROR("backfetch error %d\n", error); 156 /* if file doesn't exist anymore, then ignore the CLOSE 157 * and just update the last_rcvd. 158 */ 159 if (error == ENOENT) { 160 CDEBUG(D_KML, "manually updating remote offset uuid %s" 161 "recno %d offset %Lu\n", info.uuid, info.recno, info.kml_offset); 162 error = izo_rcvd_upd_remote(fset, info.uuid, info.recno, info.kml_offset); 163 if(error) 164 CERROR("izo_rcvd_upd_remote error %d\n", error); 165 166 } 167 } 168 169 /* propagate error to avoid further reint */ 170 } 171 172 EXIT; 173 return error; 174 } 175 176 static int reint_create(struct kml_rec *rec, struct file *dir, 177 struct lento_vfs_context *info) 178 { 179 struct run_ctxt saved_ctxt; 180 int error; ENTRY; 181 182 CDEBUG (D_KML, "=====REINT_CREATE::%s\n", rec->path); 183 info->updated_time = rec->new_objectv->pv_ctime; 184 kmlreint_pre_secure(rec, dir, &saved_ctxt); 185 error = lento_create(rec->path, rec->mode, info); 186 pop_ctxt(&saved_ctxt); 187 188 EXIT; 189 return error; 190 } 191 192 static int reint_link(struct kml_rec *rec, struct file *dir, 193 struct lento_vfs_context *info) 194 { 195 struct run_ctxt saved_ctxt; 196 int error; 197 198 ENTRY; 199 200 CDEBUG (D_KML, "=====REINT_LINK::%s -> %s\n", rec->path, rec->target); 201 info->updated_time = rec->new_objectv->pv_mtime; 202 kmlreint_pre_secure(rec, dir, &saved_ctxt); 203 error = lento_link(rec->path, rec->target, info); 204 pop_ctxt(&saved_ctxt); 205 206 EXIT; 207 return error; 208 } 209 210 static int reint_mkdir(struct kml_rec *rec, struct file *dir, 211 struct lento_vfs_context *info) 212 { 213 struct run_ctxt saved_ctxt; 214 int error; 215 216 ENTRY; 217 218 CDEBUG (D_KML, "=====REINT_MKDIR::%s\n", rec->path); 219 info->updated_time = rec->new_objectv->pv_ctime; 220 kmlreint_pre_secure(rec, dir, &saved_ctxt); 221 error = lento_mkdir(rec->path, rec->mode, info); 222 pop_ctxt(&saved_ctxt); 223 224 EXIT; 225 return error; 226 } 227 228 static int reint_mknod(struct kml_rec *rec, struct file *dir, 229 struct lento_vfs_context *info) 230 { 231 struct run_ctxt saved_ctxt; 232 int error, dev; 233 234 ENTRY; 235 236 CDEBUG (D_KML, "=====REINT_MKNOD::%s\n", rec->path); 237 info->updated_time = rec->new_objectv->pv_ctime; 238 kmlreint_pre_secure(rec, dir, &saved_ctxt); 239 240 dev = rec->rdev ?: MKDEV(rec->major, rec->minor); 241 242 error = lento_mknod(rec->path, rec->mode, dev, info); 243 pop_ctxt(&saved_ctxt); 244 245 EXIT; 246 return error; 247 } 248 249 250 static int reint_noop(struct kml_rec *rec, struct file *dir, 251 struct lento_vfs_context *info) 252 { 253 return 0; 254 } 255 256 static int reint_rename(struct kml_rec *rec, struct file *dir, 257 struct lento_vfs_context *info) 258 { 259 struct run_ctxt saved_ctxt; 260 int error; 261 262 ENTRY; 263 264 CDEBUG (D_KML, "=====REINT_RENAME::%s -> %s\n", rec->path, rec->target); 265 info->updated_time = rec->new_objectv->pv_mtime; 266 kmlreint_pre_secure(rec, dir, &saved_ctxt); 267 error = lento_rename(rec->path, rec->target, info); 268 pop_ctxt(&saved_ctxt); 269 270 EXIT; 271 return error; 272 } 273 274 static int reint_rmdir(struct kml_rec *rec, struct file *dir, 275 struct lento_vfs_context *info) 276 { 277 struct run_ctxt saved_ctxt; 278 int error; 279 char *path; 280 281 ENTRY; 282 283 path = path_join(rec->path, rec->pathlen - 1, rec->target, rec->targetlen); 284 if (path == NULL) { 285 EXIT; 286 return -ENOMEM; 287 } 288 289 CDEBUG (D_KML, "=====REINT_RMDIR::%s\n", path); 290 info->updated_time = rec->new_parentv->pv_mtime; 291 kmlreint_pre_secure(rec, dir, &saved_ctxt); 292 error = lento_rmdir(path, info); 293 pop_ctxt(&saved_ctxt); 294 295 kfree(path); 296 EXIT; 297 return error; 298 } 299 300 static int reint_setattr(struct kml_rec *rec, struct file *dir, 301 struct lento_vfs_context *info) 302 { 303 struct run_ctxt saved_ctxt; 304 struct iattr iattr; 305 int error; 306 307 ENTRY; 308 309 iattr.ia_valid = rec->valid; 310 iattr.ia_mode = (umode_t)rec->mode; 311 iattr.ia_uid = (uid_t)rec->uid; 312 iattr.ia_gid = (gid_t)rec->gid; 313 iattr.ia_size = (off_t)rec->size; 314 iattr.ia_ctime = (time_t)rec->ctime; 315 iattr.ia_mtime = (time_t)rec->mtime; 316 iattr.ia_atime = iattr.ia_mtime; /* We don't track atimes. */ 317 iattr.ia_attr_flags = rec->flags; 318 319 CDEBUG (D_KML, "=====REINT_SETATTR::%s (%d)\n", rec->path, rec->valid); 320 kmlreint_pre_secure(rec, dir, &saved_ctxt); 321 error = lento_setattr(rec->path, &iattr, info); 322 pop_ctxt(&saved_ctxt); 323 324 EXIT; 325 return error; 326 } 327 328 static int reint_symlink(struct kml_rec *rec, struct file *dir, 329 struct lento_vfs_context *info) 330 { 331 struct run_ctxt saved_ctxt; 332 int error; 333 334 ENTRY; 335 336 CDEBUG (D_KML, "=====REINT_SYMLINK::%s -> %s\n", rec->path, rec->target); 337 info->updated_time = rec->new_objectv->pv_ctime; 338 kmlreint_pre_secure(rec, dir, &saved_ctxt); 339 error = lento_symlink(rec->target, rec->path, info); 340 pop_ctxt(&saved_ctxt); 341 342 EXIT; 343 return error; 344 } 345 346 static int reint_unlink(struct kml_rec *rec, struct file *dir, 347 struct lento_vfs_context *info) 348 { 349 struct run_ctxt saved_ctxt; 350 int error; 351 char *path; 352 353 ENTRY; 354 355 path = path_join(rec->path, rec->pathlen - 1, rec->target, rec->targetlen); 356 if (path == NULL) { 357 EXIT; 358 return -ENOMEM; 359 } 360 361 CDEBUG (D_KML, "=====REINT_UNLINK::%s\n", path); 362 info->updated_time = rec->new_parentv->pv_mtime; 363 kmlreint_pre_secure(rec, dir, &saved_ctxt); 364 error = lento_unlink(path, info); 365 pop_ctxt(&saved_ctxt); 366 367 kfree(path); 368 EXIT; 369 return error; 370 } 371 372 static int branch_reint_rename(struct presto_file_set *fset, struct kml_rec *rec, 373 struct file *dir, struct lento_vfs_context *info, 374 char * kml_data, __u64 kml_size) 375 { 376 int error; 377 378 ENTRY; 379 380 error = reint_rename(rec, dir, info); 381 if (error == -ENOENT) { 382 /* normal reint failed because path was not found */ 383 struct rec_info rec; 384 385 CDEBUG(D_KML, "saving branch rename kml\n"); 386 rec.is_kml = 1; 387 rec.size = kml_size; 388 error = presto_log(fset, &rec, kml_data, kml_size, 389 NULL, 0, NULL, 0, NULL, 0); 390 if (error == 0) 391 error = presto_write_last_rcvd(&rec, fset, info); 392 } 393 394 EXIT; 395 return error; 396 } 397 398 int branch_reinter(struct presto_file_set *fset, struct kml_rec *rec, 399 struct file *dir, struct lento_vfs_context *info, 400 char * kml_data, __u64 kml_size) 401 { 402 int error = 0; 403 int op = rec->prefix.hdr->opcode; 404 405 if (op == KML_OPCODE_CLOSE) { 406 /* regular close and backfetch */ 407 error = reint_close(rec, dir, info); 408 } else if (op == KML_OPCODE_RENAME) { 409 /* rename only if name already exists */ 410 error = branch_reint_rename(fset, rec, dir, info, 411 kml_data, kml_size); 412 } else { 413 /* just rewrite kml into branch/kml and update last_rcvd */ 414 struct rec_info rec; 415 416 CDEBUG(D_KML, "Saving branch kml\n"); 417 rec.is_kml = 1; 418 rec.size = kml_size; 419 error = presto_log(fset, &rec, kml_data, kml_size, 420 NULL, 0, NULL, 0, NULL, 0); 421 if (error == 0) 422 error = presto_write_last_rcvd(&rec, fset, info); 423 } 424 425 return error; 426 } 427 428 typedef int (*reinter_t)(struct kml_rec *rec, struct file *basedir, 429 struct lento_vfs_context *info); 430 431 static reinter_t presto_reinters[KML_OPCODE_NUM] = 432 { 433 [KML_OPCODE_CLOSE] = reint_close, 434 [KML_OPCODE_CREATE] = reint_create, 435 [KML_OPCODE_LINK] = reint_link, 436 [KML_OPCODE_MKDIR] = reint_mkdir, 437 [KML_OPCODE_MKNOD] = reint_mknod, 438 [KML_OPCODE_NOOP] = reint_noop, 439 [KML_OPCODE_RENAME] = reint_rename, 440 [KML_OPCODE_RMDIR] = reint_rmdir, 441 [KML_OPCODE_SETATTR] = reint_setattr, 442 [KML_OPCODE_SYMLINK] = reint_symlink, 443 [KML_OPCODE_UNLINK] = reint_unlink, 444 }; 445 446 static inline reinter_t get_reinter(int op) 447 { 448 if (op < 0 || op >= sizeof(presto_reinters) / sizeof(reinter_t)) 449 return NULL; 450 else 451 return presto_reinters[op]; 452 } 453 454 int kml_reint_rec(struct file *dir, struct izo_ioctl_data *data) 455 { 456 char *ptr; 457 char *end; 458 struct kml_rec rec; 459 int error = 0; 460 struct lento_vfs_context info; 461 struct presto_cache *cache; 462 struct presto_file_set *fset; 463 struct presto_dentry_data *dd = presto_d2d(dir->f_dentry); 464 int op; 465 reinter_t reinter; 466 467 struct izo_rcvd_rec lr_rec; 468 int off; 469 470 ENTRY; 471 472 error = presto_prep(dir->f_dentry, &cache, &fset); 473 if ( error ) { 474 CERROR("intermezzo: Reintegration on invalid file\n"); 475 return error; 476 } 477 478 if (!dd || !dd->dd_fset || dd->dd_fset->fset_dentry != dir->f_dentry) { 479 CERROR("intermezzo: reintegration on non-fset root (ino %ld)\n", 480 dir->f_dentry->d_inode->i_ino); 481 482 return -EINVAL; 483 } 484 485 if (data->ioc_plen1 > 64 * 1024) { 486 EXIT; 487 return -ENOSPC; 488 } 489 490 ptr = fset->fset_reint_buf; 491 end = ptr + data->ioc_plen1; 492 493 if (copy_from_user(ptr, data->ioc_pbuf1, data->ioc_plen1)) { 494 EXIT; 495 error = -EFAULT; 496 goto out; 497 } 498 499 error = kml_unpack(&rec, &ptr, end); 500 if (error) { 501 EXIT; 502 error = -EFAULT; 503 goto out; 504 } 505 506 off = izo_rcvd_get(&lr_rec, fset, data->ioc_uuid); 507 if (off < 0) { 508 CERROR("No last_rcvd record, setting to 0\n"); 509 memset(&lr_rec, 0, sizeof(lr_rec)); 510 } 511 512 data->ioc_kmlsize = ptr - fset->fset_reint_buf; 513 514 if (rec.suffix->recno != lr_rec.lr_remote_recno + 1) { 515 CERROR("KML record number %Lu expected, not %d\n", 516 lr_rec.lr_remote_recno + 1, 517 rec.suffix->recno); 518 519 #if 0 520 if (!version_check(&rec, dd->dd_fset, &info)) { 521 /* FIXME: do an upcall to resolve conflicts */ 522 CERROR("intermezzo: would be a conflict!\n"); 523 error = -EINVAL; 524 EXIT; 525 goto out; 526 } 527 #endif 528 } 529 530 op = rec.prefix.hdr->opcode; 531 532 reinter = get_reinter(op); 533 if (!reinter) { 534 CERROR("%s: Unrecognized KML opcode %d\n", __FUNCTION__, op); 535 error = -EINVAL; 536 EXIT; 537 goto out; 538 } 539 540 info.kml_offset = data->ioc_offset + data->ioc_kmlsize; 541 info.recno = rec.suffix->recno; 542 info.flags = LENTO_FL_EXPECT; 543 if (data->ioc_flags) 544 info.flags |= LENTO_FL_KML; 545 546 memcpy(info.uuid, data->ioc_uuid, sizeof(info.uuid)); 547 548 if (fset->fset_flags & FSET_IS_BRANCH && data->ioc_flags) 549 error = branch_reinter(fset, &rec, dir, &info, fset->fset_reint_buf, 550 data->ioc_kmlsize); 551 else 552 error = reinter(&rec, dir, &info); 553 out: 554 EXIT; 555 return error; 556 } 557 558 int izo_get_fileid(struct file *dir, struct izo_ioctl_data *data) 559 { 560 char *buf = NULL; 561 char *ptr; 562 char *end; 563 struct kml_rec rec; 564 struct file *file; 565 struct presto_cache *cache; 566 struct presto_file_set *fset; 567 struct presto_dentry_data *dd = presto_d2d(dir->f_dentry); 568 struct run_ctxt saved_ctxt; 569 int error; 570 571 ENTRY; 572 573 error = presto_prep(dir->f_dentry, &cache, &fset); 574 if ( error ) { 575 CERROR("intermezzo: Reintegration on invalid file\n"); 576 return error; 577 } 578 579 if (!dd || !dd->dd_fset || dd->dd_fset->fset_dentry != dir->f_dentry) { 580 CERROR("intermezzo: reintegration on non-fset root (ino %ld)\n", 581 dir->f_dentry->d_inode->i_ino); 582 583 return -EINVAL; 584 } 585 586 587 PRESTO_ALLOC(buf, data->ioc_plen1); 588 if (!buf) { 589 EXIT; 590 return -ENOMEM; 591 } 592 ptr = buf; 593 end = buf + data->ioc_plen1; 594 595 if (copy_from_user(buf, data->ioc_pbuf1, data->ioc_plen1)) { 596 EXIT; 597 PRESTO_FREE(buf, data->ioc_plen1); 598 return -EFAULT; 599 } 600 601 error = kml_unpack(&rec, &ptr, end); 602 if (error) { 603 EXIT; 604 PRESTO_FREE(buf, data->ioc_plen1); 605 return -EFAULT; 606 } 607 608 kmlreint_pre_secure(&rec, dir, &saved_ctxt); 609 610 file = filp_open(rec.path, O_RDONLY, 0); 611 if (!file || IS_ERR(file)) { 612 error = PTR_ERR(file); 613 goto out; 614 } 615 data->ioc_ino = file->f_dentry->d_inode->i_ino; 616 data->ioc_generation = file->f_dentry->d_inode->i_generation; 617 filp_close(file, 0); 618 619 CDEBUG(D_FILE, "%s ino %Lx, gen %Lx\n", rec.path, 620 data->ioc_ino, data->ioc_generation); 621 622 out: 623 if (buf) 624 PRESTO_FREE(buf, data->ioc_plen1); 625 pop_ctxt(&saved_ctxt); 626 EXIT; 627 return error; 628 } 629 630
Cache object: b2109a408356efc6ecad21c963ab4a74
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]