~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/orangefs/super.c

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp