1 /* 2 * (C) 2001 Clemson University and The University of Chicago 3 * 4 * See COPYING in top-level directory. 5 */ 6 7 #include "protocol.h" 8 #include "orangefs-kernel.h" 9 #include "orangefs-bufmap.h" 10 11 #include <linux/parser.h> 12 13 /* a cache for orangefs-inode objects (i.e. orangefs inode private data) */ 14 static struct kmem_cache *orangefs_inode_cache; 15 16 /* list for storing orangefs specific superblocks in use */ 17 LIST_HEAD(orangefs_superblocks); 18 19 DEFINE_SPINLOCK(orangefs_superblocks_lock); 20 21 enum { 22 Opt_intr, 23 Opt_acl, 24 Opt_local_lock, 25 26 Opt_err 27 }; 28 29 static const match_table_t tokens = { 30 { Opt_acl, "acl" }, 31 { Opt_intr, "intr" }, 32 { Opt_local_lock, "local_lock" }, 33 { Opt_err, NULL } 34 }; 35 36 37 static int parse_mount_options(struct super_block *sb, char *options, 38 int silent) 39 { 40 struct orangefs_sb_info_s *orangefs_sb = ORANGEFS_SB(sb); 41 substring_t args[MAX_OPT_ARGS]; 42 char *p; 43 44 /* 45 * Force any potential flags that might be set from the mount 46 * to zero, ie, initialize to unset. 47 */ 48 sb->s_flags &= ~MS_POSIXACL; 49 orangefs_sb->flags &= ~ORANGEFS_OPT_INTR; 50 orangefs_sb->flags &= ~ORANGEFS_OPT_LOCAL_LOCK; 51 52 while ((p = strsep(&options, ",")) != NULL) { 53 int token; 54 55 if (!*p) 56 continue; 57 58 token = match_token(p, tokens, args); 59 switch (token) { 60 case Opt_acl: 61 sb->s_flags |= MS_POSIXACL; 62 break; 63 case Opt_intr: 64 orangefs_sb->flags |= ORANGEFS_OPT_INTR; 65 break; 66 case Opt_local_lock: 67 orangefs_sb->flags |= ORANGEFS_OPT_LOCAL_LOCK; 68 break; 69 default: 70 goto fail; 71 } 72 } 73 74 return 0; 75 fail: 76 if (!silent) 77 gossip_err("Error: mount option [%s] is not supported.\n", p); 78 return -EINVAL; 79 } 80 81 static void orangefs_inode_cache_ctor(void *req) 82 { 83 struct orangefs_inode_s *orangefs_inode = req; 84 85 inode_init_once(&orangefs_inode->vfs_inode); 86 init_rwsem(&orangefs_inode->xattr_sem); 87 88 orangefs_inode->vfs_inode.i_version = 1; 89 } 90 91 static struct inode *orangefs_alloc_inode(struct super_block *sb) 92 { 93 struct orangefs_inode_s *orangefs_inode; 94 95 orangefs_inode = kmem_cache_alloc(orangefs_inode_cache, GFP_KERNEL); 96 if (orangefs_inode == NULL) { 97 gossip_err("Failed to allocate orangefs_inode\n"); 98 return NULL; 99 } 100 101 /* 102 * We want to clear everything except for rw_semaphore and the 103 * vfs_inode. 104 */ 105 memset(&orangefs_inode->refn.khandle, 0, 16); 106 orangefs_inode->refn.fs_id = ORANGEFS_FS_ID_NULL; 107 orangefs_inode->last_failed_block_index_read = 0; 108 memset(orangefs_inode->link_target, 0, sizeof(orangefs_inode->link_target)); 109 orangefs_inode->pinode_flags = 0; 110 111 gossip_debug(GOSSIP_SUPER_DEBUG, 112 "orangefs_alloc_inode: allocated %p\n", 113 &orangefs_inode->vfs_inode); 114 return &orangefs_inode->vfs_inode; 115 } 116 117 static void orangefs_destroy_inode(struct inode *inode) 118 { 119 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); 120 121 gossip_debug(GOSSIP_SUPER_DEBUG, 122 "%s: deallocated %p destroying inode %pU\n", 123 __func__, orangefs_inode, get_khandle_from_ino(inode)); 124 125 kmem_cache_free(orangefs_inode_cache, orangefs_inode); 126 } 127 128 /* 129 * NOTE: information filled in here is typically reflected in the 130 * output of the system command 'df' 131 */ 132 static int orangefs_statfs(struct dentry *dentry, struct kstatfs *buf) 133 { 134 int ret = -ENOMEM; 135 struct orangefs_kernel_op_s *new_op = NULL; 136 int flags = 0; 137 struct super_block *sb = NULL; 138 139 sb = dentry->d_sb; 140 141 gossip_debug(GOSSIP_SUPER_DEBUG, 142 "orangefs_statfs: called on sb %p (fs_id is %d)\n", 143 sb, 144 (int)(ORANGEFS_SB(sb)->fs_id)); 145 146 new_op = op_alloc(ORANGEFS_VFS_OP_STATFS); 147 if (!new_op) 148 return ret; 149 new_op->upcall.req.statfs.fs_id = ORANGEFS_SB(sb)->fs_id; 150 151 if (ORANGEFS_SB(sb)->flags & ORANGEFS_OPT_INTR) 152 flags = ORANGEFS_OP_INTERRUPTIBLE; 153 154 ret = service_operation(new_op, "orangefs_statfs", flags); 155 156 if (new_op->downcall.status < 0) 157 goto out_op_release; 158 159 gossip_debug(GOSSIP_SUPER_DEBUG, 160 "%s: got %ld blocks available | " 161 "%ld blocks total | %ld block size | " 162 "%ld files total | %ld files avail\n", 163 __func__, 164 (long)new_op->downcall.resp.statfs.blocks_avail, 165 (long)new_op->downcall.resp.statfs.blocks_total, 166 (long)new_op->downcall.resp.statfs.block_size, 167 (long)new_op->downcall.resp.statfs.files_total, 168 (long)new_op->downcall.resp.statfs.files_avail); 169 170 buf->f_type = sb->s_magic; 171 memcpy(&buf->f_fsid, &ORANGEFS_SB(sb)->fs_id, sizeof(buf->f_fsid)); 172 buf->f_bsize = new_op->downcall.resp.statfs.block_size; 173 buf->f_namelen = ORANGEFS_NAME_MAX; 174 175 buf->f_blocks = (sector_t) new_op->downcall.resp.statfs.blocks_total; 176 buf->f_bfree = (sector_t) new_op->downcall.resp.statfs.blocks_avail; 177 buf->f_bavail = (sector_t) new_op->downcall.resp.statfs.blocks_avail; 178 buf->f_files = (sector_t) new_op->downcall.resp.statfs.files_total; 179 buf->f_ffree = (sector_t) new_op->downcall.resp.statfs.files_avail; 180 buf->f_frsize = sb->s_blocksize; 181 182 out_op_release: 183 op_release(new_op); 184 gossip_debug(GOSSIP_SUPER_DEBUG, "orangefs_statfs: returning %d\n", ret); 185 return ret; 186 } 187 188 /* 189 * Remount as initiated by VFS layer. We just need to reparse the mount 190 * options, no need to signal pvfs2-client-core about it. 191 */ 192 static int orangefs_remount_fs(struct super_block *sb, int *flags, char *data) 193 { 194 gossip_debug(GOSSIP_SUPER_DEBUG, "orangefs_remount_fs: called\n"); 195 return parse_mount_options(sb, data, 1); 196 } 197 198 /* 199 * Remount as initiated by pvfs2-client-core on restart. This is used to 200 * repopulate mount information left from previous pvfs2-client-core. 201 * 202 * the idea here is that given a valid superblock, we're 203 * re-initializing the user space client with the initial mount 204 * information specified when the super block was first initialized. 205 * this is very different than the first initialization/creation of a 206 * superblock. we use the special service_priority_operation to make 207 * sure that the mount gets ahead of any other pending operation that 208 * is waiting for servicing. this means that the pvfs2-client won't 209 * fail to start several times for all other pending operations before 210 * the client regains all of the mount information from us. 211 * NOTE: this function assumes that the request_mutex is already acquired! 212 */ 213 int orangefs_remount(struct orangefs_sb_info_s *orangefs_sb) 214 { 215 struct orangefs_kernel_op_s *new_op; 216 int ret = -EINVAL; 217 218 gossip_debug(GOSSIP_SUPER_DEBUG, "orangefs_remount: called\n"); 219 220 new_op = op_alloc(ORANGEFS_VFS_OP_FS_MOUNT); 221 if (!new_op) 222 return -ENOMEM; 223 strncpy(new_op->upcall.req.fs_mount.orangefs_config_server, 224 orangefs_sb->devname, 225 ORANGEFS_MAX_SERVER_ADDR_LEN); 226 227 gossip_debug(GOSSIP_SUPER_DEBUG, 228 "Attempting ORANGEFS Remount via host %s\n", 229 new_op->upcall.req.fs_mount.orangefs_config_server); 230 231 /* 232 * we assume that the calling function has already acquired the 233 * request_mutex to prevent other operations from bypassing 234 * this one 235 */ 236 ret = service_operation(new_op, "orangefs_remount", 237 ORANGEFS_OP_PRIORITY | ORANGEFS_OP_NO_MUTEX); 238 gossip_debug(GOSSIP_SUPER_DEBUG, 239 "orangefs_remount: mount got return value of %d\n", 240 ret); 241 if (ret == 0) { 242 /* 243 * store the id assigned to this sb -- it's just a 244 * short-lived mapping that the system interface uses 245 * to map this superblock to a particular mount entry 246 */ 247 orangefs_sb->id = new_op->downcall.resp.fs_mount.id; 248 orangefs_sb->mount_pending = 0; 249 } 250 251 op_release(new_op); 252 return ret; 253 } 254 255 int fsid_key_table_initialize(void) 256 { 257 return 0; 258 } 259 260 void fsid_key_table_finalize(void) 261 { 262 } 263 264 /* Called whenever the VFS dirties the inode in response to atime updates */ 265 static void orangefs_dirty_inode(struct inode *inode, int flags) 266 { 267 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); 268 269 gossip_debug(GOSSIP_SUPER_DEBUG, 270 "orangefs_dirty_inode: %pU\n", 271 get_khandle_from_ino(inode)); 272 SetAtimeFlag(orangefs_inode); 273 } 274 275 static const struct super_operations orangefs_s_ops = { 276 .alloc_inode = orangefs_alloc_inode, 277 .destroy_inode = orangefs_destroy_inode, 278 .dirty_inode = orangefs_dirty_inode, 279 .drop_inode = generic_delete_inode, 280 .statfs = orangefs_statfs, 281 .remount_fs = orangefs_remount_fs, 282 .show_options = generic_show_options, 283 }; 284 285 static struct dentry *orangefs_fh_to_dentry(struct super_block *sb, 286 struct fid *fid, 287 int fh_len, 288 int fh_type) 289 { 290 struct orangefs_object_kref refn; 291 292 if (fh_len < 5 || fh_type > 2) 293 return NULL; 294 295 ORANGEFS_khandle_from(&(refn.khandle), fid->raw, 16); 296 refn.fs_id = (u32) fid->raw[4]; 297 gossip_debug(GOSSIP_SUPER_DEBUG, 298 "fh_to_dentry: handle %pU, fs_id %d\n", 299 &refn.khandle, 300 refn.fs_id); 301 302 return d_obtain_alias(orangefs_iget(sb, &refn)); 303 } 304 305 static int orangefs_encode_fh(struct inode *inode, 306 __u32 *fh, 307 int *max_len, 308 struct inode *parent) 309 { 310 int len = parent ? 10 : 5; 311 int type = 1; 312 struct orangefs_object_kref refn; 313 314 if (*max_len < len) { 315 gossip_lerr("fh buffer is too small for encoding\n"); 316 *max_len = len; 317 type = 255; 318 goto out; 319 } 320 321 refn = ORANGEFS_I(inode)->refn; 322 ORANGEFS_khandle_to(&refn.khandle, fh, 16); 323 fh[4] = refn.fs_id; 324 325 gossip_debug(GOSSIP_SUPER_DEBUG, 326 "Encoding fh: handle %pU, fsid %u\n", 327 &refn.khandle, 328 refn.fs_id); 329 330 331 if (parent) { 332 refn = ORANGEFS_I(parent)->refn; 333 ORANGEFS_khandle_to(&refn.khandle, (char *) fh + 20, 16); 334 fh[9] = refn.fs_id; 335 336 type = 2; 337 gossip_debug(GOSSIP_SUPER_DEBUG, 338 "Encoding parent: handle %pU, fsid %u\n", 339 &refn.khandle, 340 refn.fs_id); 341 } 342 *max_len = len; 343 344 out: 345 return type; 346 } 347 348 static const struct export_operations orangefs_export_ops = { 349 .encode_fh = orangefs_encode_fh, 350 .fh_to_dentry = orangefs_fh_to_dentry, 351 }; 352 353 static int orangefs_fill_sb(struct super_block *sb, 354 struct orangefs_fs_mount_response *fs_mount, 355 void *data, int silent) 356 { 357 int ret = -EINVAL; 358 struct inode *root = NULL; 359 struct dentry *root_dentry = NULL; 360 struct orangefs_object_kref root_object; 361 362 /* alloc and init our private orangefs sb info */ 363 sb->s_fs_info = kzalloc(sizeof(struct orangefs_sb_info_s), GFP_KERNEL); 364 if (!ORANGEFS_SB(sb)) 365 return -ENOMEM; 366 ORANGEFS_SB(sb)->sb = sb; 367 368 ORANGEFS_SB(sb)->root_khandle = fs_mount->root_khandle; 369 ORANGEFS_SB(sb)->fs_id = fs_mount->fs_id; 370 ORANGEFS_SB(sb)->id = fs_mount->id; 371 372 if (data) { 373 ret = parse_mount_options(sb, data, silent); 374 if (ret) 375 return ret; 376 } 377 378 /* Hang the xattr handlers off the superblock */ 379 sb->s_xattr = orangefs_xattr_handlers; 380 sb->s_magic = ORANGEFS_SUPER_MAGIC; 381 sb->s_op = &orangefs_s_ops; 382 sb->s_d_op = &orangefs_dentry_operations; 383 384 sb->s_blocksize = orangefs_bufmap_size_query(); 385 sb->s_blocksize_bits = orangefs_bufmap_shift_query(); 386 sb->s_maxbytes = MAX_LFS_FILESIZE; 387 388 root_object.khandle = ORANGEFS_SB(sb)->root_khandle; 389 root_object.fs_id = ORANGEFS_SB(sb)->fs_id; 390 gossip_debug(GOSSIP_SUPER_DEBUG, 391 "get inode %pU, fsid %d\n", 392 &root_object.khandle, 393 root_object.fs_id); 394 395 root = orangefs_iget(sb, &root_object); 396 if (IS_ERR(root)) 397 return PTR_ERR(root); 398 399 gossip_debug(GOSSIP_SUPER_DEBUG, 400 "Allocated root inode [%p] with mode %x\n", 401 root, 402 root->i_mode); 403 404 /* allocates and places root dentry in dcache */ 405 root_dentry = d_make_root(root); 406 if (!root_dentry) 407 return -ENOMEM; 408 409 sb->s_export_op = &orangefs_export_ops; 410 sb->s_root = root_dentry; 411 return 0; 412 } 413 414 struct dentry *orangefs_mount(struct file_system_type *fst, 415 int flags, 416 const char *devname, 417 void *data) 418 { 419 int ret = -EINVAL; 420 struct super_block *sb = ERR_PTR(-EINVAL); 421 struct orangefs_kernel_op_s *new_op; 422 struct dentry *d = ERR_PTR(-EINVAL); 423 424 gossip_debug(GOSSIP_SUPER_DEBUG, 425 "orangefs_mount: called with devname %s\n", 426 devname); 427 428 if (!devname) { 429 gossip_err("ERROR: device name not specified.\n"); 430 return ERR_PTR(-EINVAL); 431 } 432 433 new_op = op_alloc(ORANGEFS_VFS_OP_FS_MOUNT); 434 if (!new_op) 435 return ERR_PTR(-ENOMEM); 436 437 strncpy(new_op->upcall.req.fs_mount.orangefs_config_server, 438 devname, 439 ORANGEFS_MAX_SERVER_ADDR_LEN); 440 441 gossip_debug(GOSSIP_SUPER_DEBUG, 442 "Attempting ORANGEFS Mount via host %s\n", 443 new_op->upcall.req.fs_mount.orangefs_config_server); 444 445 ret = service_operation(new_op, "orangefs_mount", 0); 446 gossip_debug(GOSSIP_SUPER_DEBUG, 447 "orangefs_mount: mount got return value of %d\n", ret); 448 if (ret) 449 goto free_op; 450 451 if (new_op->downcall.resp.fs_mount.fs_id == ORANGEFS_FS_ID_NULL) { 452 gossip_err("ERROR: Retrieved null fs_id\n"); 453 ret = -EINVAL; 454 goto free_op; 455 } 456 457 sb = sget(fst, NULL, set_anon_super, flags, NULL); 458 459 if (IS_ERR(sb)) { 460 d = ERR_CAST(sb); 461 goto free_op; 462 } 463 464 ret = orangefs_fill_sb(sb, 465 &new_op->downcall.resp.fs_mount, data, 466 flags & MS_SILENT ? 1 : 0); 467 468 if (ret) { 469 d = ERR_PTR(ret); 470 goto free_op; 471 } 472 473 /* 474 * on successful mount, store the devname and data 475 * used 476 */ 477 strncpy(ORANGEFS_SB(sb)->devname, 478 devname, 479 ORANGEFS_MAX_SERVER_ADDR_LEN); 480 481 /* mount_pending must be cleared */ 482 ORANGEFS_SB(sb)->mount_pending = 0; 483 484 /* 485 * finally, add this sb to our list of known orangefs 486 * sb's 487 */ 488 gossip_debug(GOSSIP_SUPER_DEBUG, 489 "Adding SB %p to orangefs superblocks\n", 490 ORANGEFS_SB(sb)); 491 spin_lock(&orangefs_superblocks_lock); 492 list_add_tail(&ORANGEFS_SB(sb)->list, &orangefs_superblocks); 493 spin_unlock(&orangefs_superblocks_lock); 494 op_release(new_op); 495 return dget(sb->s_root); 496 497 free_op: 498 gossip_err("orangefs_mount: mount request failed with %d\n", ret); 499 if (ret == -EINVAL) { 500 gossip_err("Ensure that all orangefs-servers have the same FS configuration files\n"); 501 gossip_err("Look at pvfs2-client-core log file (typically /tmp/pvfs2-client.log) for more details\n"); 502 } 503 504 op_release(new_op); 505 506 return d; 507 } 508 509 void orangefs_kill_sb(struct super_block *sb) 510 { 511 gossip_debug(GOSSIP_SUPER_DEBUG, "orangefs_kill_sb: called\n"); 512 513 /* provided sb cleanup */ 514 kill_anon_super(sb); 515 516 /* 517 * issue the unmount to userspace to tell it to remove the 518 * dynamic mount info it has for this superblock 519 */ 520 orangefs_unmount_sb(sb); 521 522 /* remove the sb from our list of orangefs specific sb's */ 523 524 spin_lock(&orangefs_superblocks_lock); 525 __list_del_entry(&ORANGEFS_SB(sb)->list); /* not list_del_init */ 526 ORANGEFS_SB(sb)->list.prev = NULL; 527 spin_unlock(&orangefs_superblocks_lock); 528 529 /* 530 * make sure that ORANGEFS_DEV_REMOUNT_ALL loop that might've seen us 531 * gets completed before we free the dang thing. 532 */ 533 mutex_lock(&request_mutex); 534 mutex_unlock(&request_mutex); 535 536 /* free the orangefs superblock private data */ 537 kfree(ORANGEFS_SB(sb)); 538 } 539 540 int orangefs_inode_cache_initialize(void) 541 { 542 orangefs_inode_cache = kmem_cache_create("orangefs_inode_cache", 543 sizeof(struct orangefs_inode_s), 544 0, 545 ORANGEFS_CACHE_CREATE_FLAGS, 546 orangefs_inode_cache_ctor); 547 548 if (!orangefs_inode_cache) { 549 gossip_err("Cannot create orangefs_inode_cache\n"); 550 return -ENOMEM; 551 } 552 return 0; 553 } 554 555 int orangefs_inode_cache_finalize(void) 556 { 557 kmem_cache_destroy(orangefs_inode_cache); 558 return 0; 559 } 560