1 /* 2 * (C) 2001 Clemson University and The University of Chicago 3 * 4 * See COPYING in top-level directory. 5 */ 6 #include "protocol.h" 7 #include "orangefs-kernel.h" 8 #include "orangefs-dev-proto.h" 9 #include "orangefs-bufmap.h" 10 11 __s32 fsid_of_op(struct orangefs_kernel_op_s *op) 12 { 13 __s32 fsid = ORANGEFS_FS_ID_NULL; 14 15 if (op) { 16 switch (op->upcall.type) { 17 case ORANGEFS_VFS_OP_FILE_IO: 18 fsid = op->upcall.req.io.refn.fs_id; 19 break; 20 case ORANGEFS_VFS_OP_LOOKUP: 21 fsid = op->upcall.req.lookup.parent_refn.fs_id; 22 break; 23 case ORANGEFS_VFS_OP_CREATE: 24 fsid = op->upcall.req.create.parent_refn.fs_id; 25 break; 26 case ORANGEFS_VFS_OP_GETATTR: 27 fsid = op->upcall.req.getattr.refn.fs_id; 28 break; 29 case ORANGEFS_VFS_OP_REMOVE: 30 fsid = op->upcall.req.remove.parent_refn.fs_id; 31 break; 32 case ORANGEFS_VFS_OP_MKDIR: 33 fsid = op->upcall.req.mkdir.parent_refn.fs_id; 34 break; 35 case ORANGEFS_VFS_OP_READDIR: 36 fsid = op->upcall.req.readdir.refn.fs_id; 37 break; 38 case ORANGEFS_VFS_OP_SETATTR: 39 fsid = op->upcall.req.setattr.refn.fs_id; 40 break; 41 case ORANGEFS_VFS_OP_SYMLINK: 42 fsid = op->upcall.req.sym.parent_refn.fs_id; 43 break; 44 case ORANGEFS_VFS_OP_RENAME: 45 fsid = op->upcall.req.rename.old_parent_refn.fs_id; 46 break; 47 case ORANGEFS_VFS_OP_STATFS: 48 fsid = op->upcall.req.statfs.fs_id; 49 break; 50 case ORANGEFS_VFS_OP_TRUNCATE: 51 fsid = op->upcall.req.truncate.refn.fs_id; 52 break; 53 case ORANGEFS_VFS_OP_MMAP_RA_FLUSH: 54 fsid = op->upcall.req.ra_cache_flush.refn.fs_id; 55 break; 56 case ORANGEFS_VFS_OP_FS_UMOUNT: 57 fsid = op->upcall.req.fs_umount.fs_id; 58 break; 59 case ORANGEFS_VFS_OP_GETXATTR: 60 fsid = op->upcall.req.getxattr.refn.fs_id; 61 break; 62 case ORANGEFS_VFS_OP_SETXATTR: 63 fsid = op->upcall.req.setxattr.refn.fs_id; 64 break; 65 case ORANGEFS_VFS_OP_LISTXATTR: 66 fsid = op->upcall.req.listxattr.refn.fs_id; 67 break; 68 case ORANGEFS_VFS_OP_REMOVEXATTR: 69 fsid = op->upcall.req.removexattr.refn.fs_id; 70 break; 71 case ORANGEFS_VFS_OP_FSYNC: 72 fsid = op->upcall.req.fsync.refn.fs_id; 73 break; 74 default: 75 break; 76 } 77 } 78 return fsid; 79 } 80 81 static int orangefs_inode_flags(struct ORANGEFS_sys_attr_s *attrs) 82 { 83 int flags = 0; 84 if (attrs->flags & ORANGEFS_IMMUTABLE_FL) 85 flags |= S_IMMUTABLE; 86 else 87 flags &= ~S_IMMUTABLE; 88 if (attrs->flags & ORANGEFS_APPEND_FL) 89 flags |= S_APPEND; 90 else 91 flags &= ~S_APPEND; 92 if (attrs->flags & ORANGEFS_NOATIME_FL) 93 flags |= S_NOATIME; 94 else 95 flags &= ~S_NOATIME; 96 return flags; 97 } 98 99 static int orangefs_inode_perms(struct ORANGEFS_sys_attr_s *attrs) 100 { 101 int perm_mode = 0; 102 103 if (attrs->perms & ORANGEFS_O_EXECUTE) 104 perm_mode |= S_IXOTH; 105 if (attrs->perms & ORANGEFS_O_WRITE) 106 perm_mode |= S_IWOTH; 107 if (attrs->perms & ORANGEFS_O_READ) 108 perm_mode |= S_IROTH; 109 110 if (attrs->perms & ORANGEFS_G_EXECUTE) 111 perm_mode |= S_IXGRP; 112 if (attrs->perms & ORANGEFS_G_WRITE) 113 perm_mode |= S_IWGRP; 114 if (attrs->perms & ORANGEFS_G_READ) 115 perm_mode |= S_IRGRP; 116 117 if (attrs->perms & ORANGEFS_U_EXECUTE) 118 perm_mode |= S_IXUSR; 119 if (attrs->perms & ORANGEFS_U_WRITE) 120 perm_mode |= S_IWUSR; 121 if (attrs->perms & ORANGEFS_U_READ) 122 perm_mode |= S_IRUSR; 123 124 if (attrs->perms & ORANGEFS_G_SGID) 125 perm_mode |= S_ISGID; 126 if (attrs->perms & ORANGEFS_U_SUID) 127 perm_mode |= S_ISUID; 128 129 return perm_mode; 130 } 131 132 /* 133 * NOTE: in kernel land, we never use the sys_attr->link_target for 134 * anything, so don't bother copying it into the sys_attr object here. 135 */ 136 static inline int copy_attributes_from_inode(struct inode *inode, 137 struct ORANGEFS_sys_attr_s *attrs, 138 struct iattr *iattr) 139 { 140 umode_t tmp_mode; 141 142 if (!iattr || !inode || !attrs) { 143 gossip_err("NULL iattr (%p), inode (%p), attrs (%p) " 144 "in copy_attributes_from_inode!\n", 145 iattr, 146 inode, 147 attrs); 148 return -EINVAL; 149 } 150 /* 151 * We need to be careful to only copy the attributes out of the 152 * iattr object that we know are valid. 153 */ 154 attrs->mask = 0; 155 if (iattr->ia_valid & ATTR_UID) { 156 attrs->owner = from_kuid(current_user_ns(), iattr->ia_uid); 157 attrs->mask |= ORANGEFS_ATTR_SYS_UID; 158 gossip_debug(GOSSIP_UTILS_DEBUG, "(UID) %d\n", attrs->owner); 159 } 160 if (iattr->ia_valid & ATTR_GID) { 161 attrs->group = from_kgid(current_user_ns(), iattr->ia_gid); 162 attrs->mask |= ORANGEFS_ATTR_SYS_GID; 163 gossip_debug(GOSSIP_UTILS_DEBUG, "(GID) %d\n", attrs->group); 164 } 165 166 if (iattr->ia_valid & ATTR_ATIME) { 167 attrs->mask |= ORANGEFS_ATTR_SYS_ATIME; 168 if (iattr->ia_valid & ATTR_ATIME_SET) { 169 attrs->atime = (time64_t)iattr->ia_atime.tv_sec; 170 attrs->mask |= ORANGEFS_ATTR_SYS_ATIME_SET; 171 } 172 } 173 if (iattr->ia_valid & ATTR_MTIME) { 174 attrs->mask |= ORANGEFS_ATTR_SYS_MTIME; 175 if (iattr->ia_valid & ATTR_MTIME_SET) { 176 attrs->mtime = (time64_t)iattr->ia_mtime.tv_sec; 177 attrs->mask |= ORANGEFS_ATTR_SYS_MTIME_SET; 178 } 179 } 180 if (iattr->ia_valid & ATTR_CTIME) 181 attrs->mask |= ORANGEFS_ATTR_SYS_CTIME; 182 183 /* 184 * ORANGEFS cannot set size with a setattr operation. Probably not likely 185 * to be requested through the VFS, but just in case, don't worry about 186 * ATTR_SIZE 187 */ 188 189 if (iattr->ia_valid & ATTR_MODE) { 190 tmp_mode = iattr->ia_mode; 191 if (tmp_mode & (S_ISVTX)) { 192 if (is_root_handle(inode)) { 193 /* 194 * allow sticky bit to be set on root (since 195 * it shows up that way by default anyhow), 196 * but don't show it to the server 197 */ 198 tmp_mode -= S_ISVTX; 199 } else { 200 gossip_debug(GOSSIP_UTILS_DEBUG, 201 "User attempted to set sticky bit on non-root directory; returning EINVAL.\n"); 202 return -EINVAL; 203 } 204 } 205 206 if (tmp_mode & (S_ISUID)) { 207 gossip_debug(GOSSIP_UTILS_DEBUG, 208 "Attempting to set setuid bit (not supported); returning EINVAL.\n"); 209 return -EINVAL; 210 } 211 212 attrs->perms = ORANGEFS_util_translate_mode(tmp_mode); 213 attrs->mask |= ORANGEFS_ATTR_SYS_PERM; 214 } 215 216 return 0; 217 } 218 219 static int orangefs_inode_type(enum orangefs_ds_type objtype) 220 { 221 if (objtype == ORANGEFS_TYPE_METAFILE) 222 return S_IFREG; 223 else if (objtype == ORANGEFS_TYPE_DIRECTORY) 224 return S_IFDIR; 225 else if (objtype == ORANGEFS_TYPE_SYMLINK) 226 return S_IFLNK; 227 else 228 return -1; 229 } 230 231 static int orangefs_inode_is_stale(struct inode *inode, int new, 232 struct ORANGEFS_sys_attr_s *attrs, char *link_target) 233 { 234 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); 235 int type = orangefs_inode_type(attrs->objtype); 236 if (!new) { 237 /* 238 * If the inode type or symlink target have changed then this 239 * inode is stale. 240 */ 241 if (type == -1 || !(inode->i_mode & type)) { 242 orangefs_make_bad_inode(inode); 243 return 1; 244 } 245 if (type == S_IFLNK && strncmp(orangefs_inode->link_target, 246 link_target, ORANGEFS_NAME_MAX)) { 247 orangefs_make_bad_inode(inode); 248 return 1; 249 } 250 } 251 return 0; 252 } 253 254 int orangefs_inode_getattr(struct inode *inode, int new, int size) 255 { 256 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); 257 struct orangefs_kernel_op_s *new_op; 258 loff_t inode_size, rounded_up_size; 259 int ret, type; 260 261 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: called on inode %pU\n", __func__, 262 get_khandle_from_ino(inode)); 263 264 new_op = op_alloc(ORANGEFS_VFS_OP_GETATTR); 265 if (!new_op) 266 return -ENOMEM; 267 new_op->upcall.req.getattr.refn = orangefs_inode->refn; 268 new_op->upcall.req.getattr.mask = size ? 269 ORANGEFS_ATTR_SYS_ALL_NOHINT : ORANGEFS_ATTR_SYS_ALL_NOHINT_NOSIZE; 270 271 ret = service_operation(new_op, __func__, 272 get_interruptible_flag(inode)); 273 if (ret != 0) 274 goto out; 275 276 type = orangefs_inode_type(new_op-> 277 downcall.resp.getattr.attributes.objtype); 278 ret = orangefs_inode_is_stale(inode, new, 279 &new_op->downcall.resp.getattr.attributes, 280 new_op->downcall.resp.getattr.link_target); 281 if (ret) { 282 ret = -ESTALE; 283 goto out; 284 } 285 286 switch (type) { 287 case S_IFREG: 288 inode->i_flags = orangefs_inode_flags(&new_op-> 289 downcall.resp.getattr.attributes); 290 if (size) { 291 inode_size = (loff_t)new_op-> 292 downcall.resp.getattr.attributes.size; 293 rounded_up_size = 294 (inode_size + (4096 - (inode_size % 4096))); 295 inode->i_size = inode_size; 296 orangefs_inode->blksize = 297 new_op->downcall.resp.getattr.attributes.blksize; 298 spin_lock(&inode->i_lock); 299 inode->i_bytes = inode_size; 300 inode->i_blocks = 301 (unsigned long)(rounded_up_size / 512); 302 spin_unlock(&inode->i_lock); 303 } 304 break; 305 case S_IFDIR: 306 inode->i_size = PAGE_CACHE_SIZE; 307 orangefs_inode->blksize = (1 << inode->i_blkbits); 308 spin_lock(&inode->i_lock); 309 inode_set_bytes(inode, inode->i_size); 310 spin_unlock(&inode->i_lock); 311 set_nlink(inode, 1); 312 break; 313 case S_IFLNK: 314 if (new) { 315 inode->i_size = (loff_t)strlen(new_op-> 316 downcall.resp.getattr.link_target); 317 orangefs_inode->blksize = (1 << inode->i_blkbits); 318 strlcpy(orangefs_inode->link_target, 319 new_op->downcall.resp.getattr.link_target, 320 ORANGEFS_NAME_MAX); 321 inode->i_link = orangefs_inode->link_target; 322 } 323 break; 324 } 325 326 inode->i_uid = make_kuid(&init_user_ns, new_op-> 327 downcall.resp.getattr.attributes.owner); 328 inode->i_gid = make_kgid(&init_user_ns, new_op-> 329 downcall.resp.getattr.attributes.group); 330 inode->i_atime.tv_sec = (time64_t)new_op-> 331 downcall.resp.getattr.attributes.atime; 332 inode->i_mtime.tv_sec = (time64_t)new_op-> 333 downcall.resp.getattr.attributes.mtime; 334 inode->i_ctime.tv_sec = (time64_t)new_op-> 335 downcall.resp.getattr.attributes.ctime; 336 inode->i_atime.tv_nsec = 0; 337 inode->i_mtime.tv_nsec = 0; 338 inode->i_ctime.tv_nsec = 0; 339 340 /* special case: mark the root inode as sticky */ 341 inode->i_mode = type | (is_root_handle(inode) ? S_ISVTX : 0) | 342 orangefs_inode_perms(&new_op->downcall.resp.getattr.attributes); 343 344 ret = 0; 345 out: 346 op_release(new_op); 347 return ret; 348 } 349 350 int orangefs_inode_check_changed(struct inode *inode) 351 { 352 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); 353 struct orangefs_kernel_op_s *new_op; 354 int ret; 355 356 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: called on inode %pU\n", __func__, 357 get_khandle_from_ino(inode)); 358 359 new_op = op_alloc(ORANGEFS_VFS_OP_GETATTR); 360 if (!new_op) 361 return -ENOMEM; 362 new_op->upcall.req.getattr.refn = orangefs_inode->refn; 363 new_op->upcall.req.getattr.mask = ORANGEFS_ATTR_SYS_TYPE | 364 ORANGEFS_ATTR_SYS_LNK_TARGET; 365 366 ret = service_operation(new_op, __func__, 367 get_interruptible_flag(inode)); 368 if (ret != 0) 369 goto out; 370 371 ret = orangefs_inode_is_stale(inode, 0, 372 &new_op->downcall.resp.getattr.attributes, 373 new_op->downcall.resp.getattr.link_target); 374 out: 375 op_release(new_op); 376 return ret; 377 } 378 379 /* 380 * issues a orangefs setattr request to make sure the new attribute values 381 * take effect if successful. returns 0 on success; -errno otherwise 382 */ 383 int orangefs_inode_setattr(struct inode *inode, struct iattr *iattr) 384 { 385 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); 386 struct orangefs_kernel_op_s *new_op; 387 int ret; 388 389 new_op = op_alloc(ORANGEFS_VFS_OP_SETATTR); 390 if (!new_op) 391 return -ENOMEM; 392 393 new_op->upcall.req.setattr.refn = orangefs_inode->refn; 394 ret = copy_attributes_from_inode(inode, 395 &new_op->upcall.req.setattr.attributes, 396 iattr); 397 if (ret >= 0) { 398 ret = service_operation(new_op, __func__, 399 get_interruptible_flag(inode)); 400 401 gossip_debug(GOSSIP_UTILS_DEBUG, 402 "orangefs_inode_setattr: returning %d\n", 403 ret); 404 } 405 406 op_release(new_op); 407 408 /* 409 * successful setattr should clear the atime, mtime and 410 * ctime flags. 411 */ 412 if (ret == 0) { 413 ClearAtimeFlag(orangefs_inode); 414 ClearMtimeFlag(orangefs_inode); 415 ClearCtimeFlag(orangefs_inode); 416 ClearModeFlag(orangefs_inode); 417 } 418 419 return ret; 420 } 421 422 int orangefs_flush_inode(struct inode *inode) 423 { 424 /* 425 * If it is a dirty inode, this function gets called. 426 * Gather all the information that needs to be setattr'ed 427 * Right now, this will only be used for mode, atime, mtime 428 * and/or ctime. 429 */ 430 struct iattr wbattr; 431 int ret; 432 int mtime_flag; 433 int ctime_flag; 434 int atime_flag; 435 int mode_flag; 436 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); 437 438 memset(&wbattr, 0, sizeof(wbattr)); 439 440 /* 441 * check inode flags up front, and clear them if they are set. This 442 * will prevent multiple processes from all trying to flush the same 443 * inode if they call close() simultaneously 444 */ 445 mtime_flag = MtimeFlag(orangefs_inode); 446 ClearMtimeFlag(orangefs_inode); 447 ctime_flag = CtimeFlag(orangefs_inode); 448 ClearCtimeFlag(orangefs_inode); 449 atime_flag = AtimeFlag(orangefs_inode); 450 ClearAtimeFlag(orangefs_inode); 451 mode_flag = ModeFlag(orangefs_inode); 452 ClearModeFlag(orangefs_inode); 453 454 /* -- Lazy atime,mtime and ctime update -- 455 * Note: all times are dictated by server in the new scheme 456 * and not by the clients 457 * 458 * Also mode updates are being handled now.. 459 */ 460 461 if (mtime_flag) 462 wbattr.ia_valid |= ATTR_MTIME; 463 if (ctime_flag) 464 wbattr.ia_valid |= ATTR_CTIME; 465 if (atime_flag) 466 wbattr.ia_valid |= ATTR_ATIME; 467 468 if (mode_flag) { 469 wbattr.ia_mode = inode->i_mode; 470 wbattr.ia_valid |= ATTR_MODE; 471 } 472 473 gossip_debug(GOSSIP_UTILS_DEBUG, 474 "*********** orangefs_flush_inode: %pU " 475 "(ia_valid %d)\n", 476 get_khandle_from_ino(inode), 477 wbattr.ia_valid); 478 if (wbattr.ia_valid == 0) { 479 gossip_debug(GOSSIP_UTILS_DEBUG, 480 "orangefs_flush_inode skipping setattr()\n"); 481 return 0; 482 } 483 484 gossip_debug(GOSSIP_UTILS_DEBUG, 485 "orangefs_flush_inode (%pU) writing mode %o\n", 486 get_khandle_from_ino(inode), 487 inode->i_mode); 488 489 ret = orangefs_inode_setattr(inode, &wbattr); 490 491 return ret; 492 } 493 494 int orangefs_unmount_sb(struct super_block *sb) 495 { 496 int ret = -EINVAL; 497 struct orangefs_kernel_op_s *new_op = NULL; 498 499 gossip_debug(GOSSIP_UTILS_DEBUG, 500 "orangefs_unmount_sb called on sb %p\n", 501 sb); 502 503 new_op = op_alloc(ORANGEFS_VFS_OP_FS_UMOUNT); 504 if (!new_op) 505 return -ENOMEM; 506 new_op->upcall.req.fs_umount.id = ORANGEFS_SB(sb)->id; 507 new_op->upcall.req.fs_umount.fs_id = ORANGEFS_SB(sb)->fs_id; 508 strncpy(new_op->upcall.req.fs_umount.orangefs_config_server, 509 ORANGEFS_SB(sb)->devname, 510 ORANGEFS_MAX_SERVER_ADDR_LEN); 511 512 gossip_debug(GOSSIP_UTILS_DEBUG, 513 "Attempting ORANGEFS Unmount via host %s\n", 514 new_op->upcall.req.fs_umount.orangefs_config_server); 515 516 ret = service_operation(new_op, "orangefs_fs_umount", 0); 517 518 gossip_debug(GOSSIP_UTILS_DEBUG, 519 "orangefs_unmount: got return value of %d\n", ret); 520 if (ret) 521 sb = ERR_PTR(ret); 522 else 523 ORANGEFS_SB(sb)->mount_pending = 1; 524 525 op_release(new_op); 526 return ret; 527 } 528 529 void orangefs_make_bad_inode(struct inode *inode) 530 { 531 if (is_root_handle(inode)) { 532 /* 533 * if this occurs, the pvfs2-client-core was killed but we 534 * can't afford to lose the inode operations and such 535 * associated with the root handle in any case. 536 */ 537 gossip_debug(GOSSIP_UTILS_DEBUG, 538 "*** NOT making bad root inode %pU\n", 539 get_khandle_from_ino(inode)); 540 } else { 541 gossip_debug(GOSSIP_UTILS_DEBUG, 542 "*** making bad inode %pU\n", 543 get_khandle_from_ino(inode)); 544 make_bad_inode(inode); 545 } 546 } 547 548 /* 549 * The following is a very dirty hack that is now a permanent part of the 550 * ORANGEFS protocol. See protocol.h for more error definitions. 551 */ 552 553 /* The order matches include/orangefs-types.h in the OrangeFS source. */ 554 static int PINT_errno_mapping[] = { 555 0, EPERM, ENOENT, EINTR, EIO, ENXIO, EBADF, EAGAIN, ENOMEM, 556 EFAULT, EBUSY, EEXIST, ENODEV, ENOTDIR, EISDIR, EINVAL, EMFILE, 557 EFBIG, ENOSPC, EROFS, EMLINK, EPIPE, EDEADLK, ENAMETOOLONG, 558 ENOLCK, ENOSYS, ENOTEMPTY, ELOOP, EWOULDBLOCK, ENOMSG, EUNATCH, 559 EBADR, EDEADLOCK, ENODATA, ETIME, ENONET, EREMOTE, ECOMM, 560 EPROTO, EBADMSG, EOVERFLOW, ERESTART, EMSGSIZE, EPROTOTYPE, 561 ENOPROTOOPT, EPROTONOSUPPORT, EOPNOTSUPP, EADDRINUSE, 562 EADDRNOTAVAIL, ENETDOWN, ENETUNREACH, ENETRESET, ENOBUFS, 563 ETIMEDOUT, ECONNREFUSED, EHOSTDOWN, EHOSTUNREACH, EALREADY, 564 EACCES, ECONNRESET, ERANGE 565 }; 566 567 int orangefs_normalize_to_errno(__s32 error_code) 568 { 569 __u32 i; 570 571 /* Success */ 572 if (error_code == 0) { 573 return 0; 574 /* 575 * This shouldn't ever happen. If it does it should be fixed on the 576 * server. 577 */ 578 } else if (error_code > 0) { 579 gossip_err("orangefs: error status receieved.\n"); 580 gossip_err("orangefs: assuming error code is inverted.\n"); 581 error_code = -error_code; 582 } 583 584 /* 585 * XXX: This is very bad since error codes from ORANGEFS may not be 586 * suitable for return into userspace. 587 */ 588 589 /* 590 * Convert ORANGEFS error values into errno values suitable for return 591 * from the kernel. 592 */ 593 if ((-error_code) & ORANGEFS_NON_ERRNO_ERROR_BIT) { 594 if (((-error_code) & 595 (ORANGEFS_ERROR_NUMBER_BITS|ORANGEFS_NON_ERRNO_ERROR_BIT| 596 ORANGEFS_ERROR_BIT)) == ORANGEFS_ECANCEL) { 597 /* 598 * cancellation error codes generally correspond to 599 * a timeout from the client's perspective 600 */ 601 error_code = -ETIMEDOUT; 602 } else { 603 /* assume a default error code */ 604 gossip_err("orangefs: warning: got error code without errno equivalent: %d.\n", error_code); 605 error_code = -EINVAL; 606 } 607 608 /* Convert ORANGEFS encoded errno values into regular errno values. */ 609 } else if ((-error_code) & ORANGEFS_ERROR_BIT) { 610 i = (-error_code) & ~(ORANGEFS_ERROR_BIT|ORANGEFS_ERROR_CLASS_BITS); 611 if (i < sizeof(PINT_errno_mapping)/sizeof(*PINT_errno_mapping)) 612 error_code = -PINT_errno_mapping[i]; 613 else 614 error_code = -EINVAL; 615 616 /* 617 * Only ORANGEFS protocol error codes should ever come here. Otherwise 618 * there is a bug somewhere. 619 */ 620 } else { 621 gossip_err("orangefs: orangefs_normalize_to_errno: got error code which is not from ORANGEFS.\n"); 622 } 623 return error_code; 624 } 625 626 #define NUM_MODES 11 627 __s32 ORANGEFS_util_translate_mode(int mode) 628 { 629 int ret = 0; 630 int i = 0; 631 static int modes[NUM_MODES] = { 632 S_IXOTH, S_IWOTH, S_IROTH, 633 S_IXGRP, S_IWGRP, S_IRGRP, 634 S_IXUSR, S_IWUSR, S_IRUSR, 635 S_ISGID, S_ISUID 636 }; 637 static int orangefs_modes[NUM_MODES] = { 638 ORANGEFS_O_EXECUTE, ORANGEFS_O_WRITE, ORANGEFS_O_READ, 639 ORANGEFS_G_EXECUTE, ORANGEFS_G_WRITE, ORANGEFS_G_READ, 640 ORANGEFS_U_EXECUTE, ORANGEFS_U_WRITE, ORANGEFS_U_READ, 641 ORANGEFS_G_SGID, ORANGEFS_U_SUID 642 }; 643 644 for (i = 0; i < NUM_MODES; i++) 645 if (mode & modes[i]) 646 ret |= orangefs_modes[i]; 647 648 return ret; 649 } 650 #undef NUM_MODES 651 652 /* 653 * After obtaining a string representation of the client's debug 654 * keywords and their associated masks, this function is called to build an 655 * array of these values. 656 */ 657 int orangefs_prepare_cdm_array(char *debug_array_string) 658 { 659 int i; 660 int rc = -EINVAL; 661 char *cds_head = NULL; 662 char *cds_delimiter = NULL; 663 int keyword_len = 0; 664 665 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__); 666 667 /* 668 * figure out how many elements the cdm_array needs. 669 */ 670 for (i = 0; i < strlen(debug_array_string); i++) 671 if (debug_array_string[i] == '\n') 672 cdm_element_count++; 673 674 if (!cdm_element_count) { 675 pr_info("No elements in client debug array string!\n"); 676 goto out; 677 } 678 679 cdm_array = 680 kzalloc(cdm_element_count * sizeof(struct client_debug_mask), 681 GFP_KERNEL); 682 if (!cdm_array) { 683 pr_info("malloc failed for cdm_array!\n"); 684 rc = -ENOMEM; 685 goto out; 686 } 687 688 cds_head = debug_array_string; 689 690 for (i = 0; i < cdm_element_count; i++) { 691 cds_delimiter = strchr(cds_head, '\n'); 692 *cds_delimiter = '\0'; 693 694 keyword_len = strcspn(cds_head, " "); 695 696 cdm_array[i].keyword = kzalloc(keyword_len + 1, GFP_KERNEL); 697 if (!cdm_array[i].keyword) { 698 rc = -ENOMEM; 699 goto out; 700 } 701 702 sscanf(cds_head, 703 "%s %llx %llx", 704 cdm_array[i].keyword, 705 (unsigned long long *)&(cdm_array[i].mask1), 706 (unsigned long long *)&(cdm_array[i].mask2)); 707 708 if (!strcmp(cdm_array[i].keyword, ORANGEFS_VERBOSE)) 709 client_verbose_index = i; 710 711 if (!strcmp(cdm_array[i].keyword, ORANGEFS_ALL)) 712 client_all_index = i; 713 714 cds_head = cds_delimiter + 1; 715 } 716 717 rc = cdm_element_count; 718 719 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: rc:%d:\n", __func__, rc); 720 721 out: 722 723 return rc; 724 725 } 726 727 /* 728 * /sys/kernel/debug/orangefs/debug-help can be catted to 729 * see all the available kernel and client debug keywords. 730 * 731 * When the kernel boots, we have no idea what keywords the 732 * client supports, nor their associated masks. 733 * 734 * We pass through this function once at boot and stamp a 735 * boilerplate "we don't know" message for the client in the 736 * debug-help file. We pass through here again when the client 737 * starts and then we can fill out the debug-help file fully. 738 * 739 * The client might be restarted any number of times between 740 * reboots, we only build the debug-help file the first time. 741 */ 742 int orangefs_prepare_debugfs_help_string(int at_boot) 743 { 744 int rc = -EINVAL; 745 int i; 746 int byte_count = 0; 747 char *client_title = "Client Debug Keywords:\n"; 748 char *kernel_title = "Kernel Debug Keywords:\n"; 749 750 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__); 751 752 if (at_boot) { 753 byte_count += strlen(HELP_STRING_UNINITIALIZED); 754 client_title = HELP_STRING_UNINITIALIZED; 755 } else { 756 /* 757 * fill the client keyword/mask array and remember 758 * how many elements there were. 759 */ 760 cdm_element_count = 761 orangefs_prepare_cdm_array(client_debug_array_string); 762 if (cdm_element_count <= 0) 763 goto out; 764 765 /* Count the bytes destined for debug_help_string. */ 766 byte_count += strlen(client_title); 767 768 for (i = 0; i < cdm_element_count; i++) { 769 byte_count += strlen(cdm_array[i].keyword + 2); 770 if (byte_count >= DEBUG_HELP_STRING_SIZE) { 771 pr_info("%s: overflow 1!\n", __func__); 772 goto out; 773 } 774 } 775 776 gossip_debug(GOSSIP_UTILS_DEBUG, 777 "%s: cdm_element_count:%d:\n", 778 __func__, 779 cdm_element_count); 780 } 781 782 byte_count += strlen(kernel_title); 783 for (i = 0; i < num_kmod_keyword_mask_map; i++) { 784 byte_count += 785 strlen(s_kmod_keyword_mask_map[i].keyword + 2); 786 if (byte_count >= DEBUG_HELP_STRING_SIZE) { 787 pr_info("%s: overflow 2!\n", __func__); 788 goto out; 789 } 790 } 791 792 /* build debug_help_string. */ 793 debug_help_string = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL); 794 if (!debug_help_string) { 795 rc = -ENOMEM; 796 goto out; 797 } 798 799 strcat(debug_help_string, client_title); 800 801 if (!at_boot) { 802 for (i = 0; i < cdm_element_count; i++) { 803 strcat(debug_help_string, "\t"); 804 strcat(debug_help_string, cdm_array[i].keyword); 805 strcat(debug_help_string, "\n"); 806 } 807 } 808 809 strcat(debug_help_string, "\n"); 810 strcat(debug_help_string, kernel_title); 811 812 for (i = 0; i < num_kmod_keyword_mask_map; i++) { 813 strcat(debug_help_string, "\t"); 814 strcat(debug_help_string, s_kmod_keyword_mask_map[i].keyword); 815 strcat(debug_help_string, "\n"); 816 } 817 818 rc = 0; 819 820 out: 821 822 return rc; 823 824 } 825 826 /* 827 * kernel = type 0 828 * client = type 1 829 */ 830 void debug_mask_to_string(void *mask, int type) 831 { 832 int i; 833 int len = 0; 834 char *debug_string; 835 int element_count = 0; 836 837 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__); 838 839 if (type) { 840 debug_string = client_debug_string; 841 element_count = cdm_element_count; 842 } else { 843 debug_string = kernel_debug_string; 844 element_count = num_kmod_keyword_mask_map; 845 } 846 847 memset(debug_string, 0, ORANGEFS_MAX_DEBUG_STRING_LEN); 848 849 /* 850 * Some keywords, like "all" or "verbose", are amalgams of 851 * numerous other keywords. Make a special check for those 852 * before grinding through the whole mask only to find out 853 * later... 854 */ 855 if (check_amalgam_keyword(mask, type)) 856 goto out; 857 858 /* Build the debug string. */ 859 for (i = 0; i < element_count; i++) 860 if (type) 861 do_c_string(mask, i); 862 else 863 do_k_string(mask, i); 864 865 len = strlen(debug_string); 866 867 if ((len) && (type)) 868 client_debug_string[len - 1] = '\0'; 869 else if (len) 870 kernel_debug_string[len - 1] = '\0'; 871 else if (type) 872 strcpy(client_debug_string, "none"); 873 else 874 strcpy(kernel_debug_string, "none"); 875 876 out: 877 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: string:%s:\n", __func__, debug_string); 878 879 return; 880 881 } 882 883 void do_k_string(void *k_mask, int index) 884 { 885 __u64 *mask = (__u64 *) k_mask; 886 887 if (keyword_is_amalgam((char *) s_kmod_keyword_mask_map[index].keyword)) 888 goto out; 889 890 if (*mask & s_kmod_keyword_mask_map[index].mask_val) { 891 if ((strlen(kernel_debug_string) + 892 strlen(s_kmod_keyword_mask_map[index].keyword)) 893 < ORANGEFS_MAX_DEBUG_STRING_LEN - 1) { 894 strcat(kernel_debug_string, 895 s_kmod_keyword_mask_map[index].keyword); 896 strcat(kernel_debug_string, ","); 897 } else { 898 gossip_err("%s: overflow!\n", __func__); 899 strcpy(kernel_debug_string, ORANGEFS_ALL); 900 goto out; 901 } 902 } 903 904 out: 905 906 return; 907 } 908 909 void do_c_string(void *c_mask, int index) 910 { 911 struct client_debug_mask *mask = (struct client_debug_mask *) c_mask; 912 913 if (keyword_is_amalgam(cdm_array[index].keyword)) 914 goto out; 915 916 if ((mask->mask1 & cdm_array[index].mask1) || 917 (mask->mask2 & cdm_array[index].mask2)) { 918 if ((strlen(client_debug_string) + 919 strlen(cdm_array[index].keyword) + 1) 920 < ORANGEFS_MAX_DEBUG_STRING_LEN - 2) { 921 strcat(client_debug_string, 922 cdm_array[index].keyword); 923 strcat(client_debug_string, ","); 924 } else { 925 gossip_err("%s: overflow!\n", __func__); 926 strcpy(client_debug_string, ORANGEFS_ALL); 927 goto out; 928 } 929 } 930 out: 931 return; 932 } 933 934 int keyword_is_amalgam(char *keyword) 935 { 936 int rc = 0; 937 938 if ((!strcmp(keyword, ORANGEFS_ALL)) || (!strcmp(keyword, ORANGEFS_VERBOSE))) 939 rc = 1; 940 941 return rc; 942 } 943 944 /* 945 * kernel = type 0 946 * client = type 1 947 * 948 * return 1 if we found an amalgam. 949 */ 950 int check_amalgam_keyword(void *mask, int type) 951 { 952 __u64 *k_mask; 953 struct client_debug_mask *c_mask; 954 int k_all_index = num_kmod_keyword_mask_map - 1; 955 int rc = 0; 956 957 if (type) { 958 c_mask = (struct client_debug_mask *) mask; 959 960 if ((c_mask->mask1 == cdm_array[client_all_index].mask1) && 961 (c_mask->mask2 == cdm_array[client_all_index].mask2)) { 962 strcpy(client_debug_string, ORANGEFS_ALL); 963 rc = 1; 964 goto out; 965 } 966 967 if ((c_mask->mask1 == cdm_array[client_verbose_index].mask1) && 968 (c_mask->mask2 == cdm_array[client_verbose_index].mask2)) { 969 strcpy(client_debug_string, ORANGEFS_VERBOSE); 970 rc = 1; 971 goto out; 972 } 973 974 } else { 975 k_mask = (__u64 *) mask; 976 977 if (*k_mask >= s_kmod_keyword_mask_map[k_all_index].mask_val) { 978 strcpy(kernel_debug_string, ORANGEFS_ALL); 979 rc = 1; 980 goto out; 981 } 982 } 983 984 out: 985 986 return rc; 987 } 988 989 /* 990 * kernel = type 0 991 * client = type 1 992 */ 993 void debug_string_to_mask(char *debug_string, void *mask, int type) 994 { 995 char *unchecked_keyword; 996 int i; 997 char *strsep_fodder = kstrdup(debug_string, GFP_KERNEL); 998 char *original_pointer; 999 int element_count = 0; 1000 struct client_debug_mask *c_mask; 1001 __u64 *k_mask; 1002 1003 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__); 1004 1005 if (type) { 1006 c_mask = (struct client_debug_mask *)mask; 1007 element_count = cdm_element_count; 1008 } else { 1009 k_mask = (__u64 *)mask; 1010 *k_mask = 0; 1011 element_count = num_kmod_keyword_mask_map; 1012 } 1013 1014 original_pointer = strsep_fodder; 1015 while ((unchecked_keyword = strsep(&strsep_fodder, ","))) 1016 if (strlen(unchecked_keyword)) { 1017 for (i = 0; i < element_count; i++) 1018 if (type) 1019 do_c_mask(i, 1020 unchecked_keyword, 1021 &c_mask); 1022 else 1023 do_k_mask(i, 1024 unchecked_keyword, 1025 &k_mask); 1026 } 1027 1028 kfree(original_pointer); 1029 } 1030 1031 void do_c_mask(int i, 1032 char *unchecked_keyword, 1033 struct client_debug_mask **sane_mask) 1034 { 1035 1036 if (!strcmp(cdm_array[i].keyword, unchecked_keyword)) { 1037 (**sane_mask).mask1 = (**sane_mask).mask1 | cdm_array[i].mask1; 1038 (**sane_mask).mask2 = (**sane_mask).mask2 | cdm_array[i].mask2; 1039 } 1040 } 1041 1042 void do_k_mask(int i, char *unchecked_keyword, __u64 **sane_mask) 1043 { 1044 1045 if (!strcmp(s_kmod_keyword_mask_map[i].keyword, unchecked_keyword)) 1046 **sane_mask = (**sane_mask) | 1047 s_kmod_keyword_mask_map[i].mask_val; 1048 } 1049