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

TOMOYO Linux Cross Reference
Linux/fs/orangefs/orangefs-utils.c

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ 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.69 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ 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 #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_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                         ret = strscpy(orangefs_inode->link_target,
319                             new_op->downcall.resp.getattr.link_target,
320                             ORANGEFS_NAME_MAX);
321                         if (ret == -E2BIG) {
322                                 ret = -EIO;
323                                 goto out;
324                         }
325                         inode->i_link = orangefs_inode->link_target;
326                 }
327                 break;
328         }
329 
330         inode->i_uid = make_kuid(&init_user_ns, new_op->
331             downcall.resp.getattr.attributes.owner);
332         inode->i_gid = make_kgid(&init_user_ns, new_op->
333             downcall.resp.getattr.attributes.group);
334         inode->i_atime.tv_sec = (time64_t)new_op->
335             downcall.resp.getattr.attributes.atime;
336         inode->i_mtime.tv_sec = (time64_t)new_op->
337             downcall.resp.getattr.attributes.mtime;
338         inode->i_ctime.tv_sec = (time64_t)new_op->
339             downcall.resp.getattr.attributes.ctime;
340         inode->i_atime.tv_nsec = 0;
341         inode->i_mtime.tv_nsec = 0;
342         inode->i_ctime.tv_nsec = 0;
343 
344         /* special case: mark the root inode as sticky */
345         inode->i_mode = type | (is_root_handle(inode) ? S_ISVTX : 0) |
346             orangefs_inode_perms(&new_op->downcall.resp.getattr.attributes);
347 
348         ret = 0;
349 out:
350         op_release(new_op);
351         return ret;
352 }
353 
354 int orangefs_inode_check_changed(struct inode *inode)
355 {
356         struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
357         struct orangefs_kernel_op_s *new_op;
358         int ret;
359 
360         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: called on inode %pU\n", __func__,
361             get_khandle_from_ino(inode));
362 
363         new_op = op_alloc(ORANGEFS_VFS_OP_GETATTR);
364         if (!new_op)
365                 return -ENOMEM;
366         new_op->upcall.req.getattr.refn = orangefs_inode->refn;
367         new_op->upcall.req.getattr.mask = ORANGEFS_ATTR_SYS_TYPE |
368             ORANGEFS_ATTR_SYS_LNK_TARGET;
369 
370         ret = service_operation(new_op, __func__,
371             get_interruptible_flag(inode));
372         if (ret != 0)
373                 goto out;
374 
375         ret = orangefs_inode_is_stale(inode, 0,
376             &new_op->downcall.resp.getattr.attributes,
377             new_op->downcall.resp.getattr.link_target);
378 out:
379         op_release(new_op);
380         return ret;
381 }
382 
383 /*
384  * issues a orangefs setattr request to make sure the new attribute values
385  * take effect if successful.  returns 0 on success; -errno otherwise
386  */
387 int orangefs_inode_setattr(struct inode *inode, struct iattr *iattr)
388 {
389         struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
390         struct orangefs_kernel_op_s *new_op;
391         int ret;
392 
393         new_op = op_alloc(ORANGEFS_VFS_OP_SETATTR);
394         if (!new_op)
395                 return -ENOMEM;
396 
397         new_op->upcall.req.setattr.refn = orangefs_inode->refn;
398         ret = copy_attributes_from_inode(inode,
399                        &new_op->upcall.req.setattr.attributes,
400                        iattr);
401         if (ret >= 0) {
402                 ret = service_operation(new_op, __func__,
403                                 get_interruptible_flag(inode));
404 
405                 gossip_debug(GOSSIP_UTILS_DEBUG,
406                              "orangefs_inode_setattr: returning %d\n",
407                              ret);
408         }
409 
410         op_release(new_op);
411 
412         /*
413          * successful setattr should clear the atime, mtime and
414          * ctime flags.
415          */
416         if (ret == 0) {
417                 ClearAtimeFlag(orangefs_inode);
418                 ClearMtimeFlag(orangefs_inode);
419                 ClearCtimeFlag(orangefs_inode);
420                 ClearModeFlag(orangefs_inode);
421         }
422 
423         return ret;
424 }
425 
426 int orangefs_flush_inode(struct inode *inode)
427 {
428         /*
429          * If it is a dirty inode, this function gets called.
430          * Gather all the information that needs to be setattr'ed
431          * Right now, this will only be used for mode, atime, mtime
432          * and/or ctime.
433          */
434         struct iattr wbattr;
435         int ret;
436         int mtime_flag;
437         int ctime_flag;
438         int atime_flag;
439         int mode_flag;
440         struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
441 
442         memset(&wbattr, 0, sizeof(wbattr));
443 
444         /*
445          * check inode flags up front, and clear them if they are set.  This
446          * will prevent multiple processes from all trying to flush the same
447          * inode if they call close() simultaneously
448          */
449         mtime_flag = MtimeFlag(orangefs_inode);
450         ClearMtimeFlag(orangefs_inode);
451         ctime_flag = CtimeFlag(orangefs_inode);
452         ClearCtimeFlag(orangefs_inode);
453         atime_flag = AtimeFlag(orangefs_inode);
454         ClearAtimeFlag(orangefs_inode);
455         mode_flag = ModeFlag(orangefs_inode);
456         ClearModeFlag(orangefs_inode);
457 
458         /*  -- Lazy atime,mtime and ctime update --
459          * Note: all times are dictated by server in the new scheme
460          * and not by the clients
461          *
462          * Also mode updates are being handled now..
463          */
464 
465         if (mtime_flag)
466                 wbattr.ia_valid |= ATTR_MTIME;
467         if (ctime_flag)
468                 wbattr.ia_valid |= ATTR_CTIME;
469         if (atime_flag)
470                 wbattr.ia_valid |= ATTR_ATIME;
471 
472         if (mode_flag) {
473                 wbattr.ia_mode = inode->i_mode;
474                 wbattr.ia_valid |= ATTR_MODE;
475         }
476 
477         gossip_debug(GOSSIP_UTILS_DEBUG,
478                      "*********** orangefs_flush_inode: %pU "
479                      "(ia_valid %d)\n",
480                      get_khandle_from_ino(inode),
481                      wbattr.ia_valid);
482         if (wbattr.ia_valid == 0) {
483                 gossip_debug(GOSSIP_UTILS_DEBUG,
484                              "orangefs_flush_inode skipping setattr()\n");
485                 return 0;
486         }
487 
488         gossip_debug(GOSSIP_UTILS_DEBUG,
489                      "orangefs_flush_inode (%pU) writing mode %o\n",
490                      get_khandle_from_ino(inode),
491                      inode->i_mode);
492 
493         ret = orangefs_inode_setattr(inode, &wbattr);
494 
495         return ret;
496 }
497 
498 int orangefs_unmount_sb(struct super_block *sb)
499 {
500         int ret = -EINVAL;
501         struct orangefs_kernel_op_s *new_op = NULL;
502 
503         gossip_debug(GOSSIP_UTILS_DEBUG,
504                      "orangefs_unmount_sb called on sb %p\n",
505                      sb);
506 
507         new_op = op_alloc(ORANGEFS_VFS_OP_FS_UMOUNT);
508         if (!new_op)
509                 return -ENOMEM;
510         new_op->upcall.req.fs_umount.id = ORANGEFS_SB(sb)->id;
511         new_op->upcall.req.fs_umount.fs_id = ORANGEFS_SB(sb)->fs_id;
512         strncpy(new_op->upcall.req.fs_umount.orangefs_config_server,
513                 ORANGEFS_SB(sb)->devname,
514                 ORANGEFS_MAX_SERVER_ADDR_LEN);
515 
516         gossip_debug(GOSSIP_UTILS_DEBUG,
517                      "Attempting ORANGEFS Unmount via host %s\n",
518                      new_op->upcall.req.fs_umount.orangefs_config_server);
519 
520         ret = service_operation(new_op, "orangefs_fs_umount", 0);
521 
522         gossip_debug(GOSSIP_UTILS_DEBUG,
523                      "orangefs_unmount: got return value of %d\n", ret);
524         if (ret)
525                 sb = ERR_PTR(ret);
526         else
527                 ORANGEFS_SB(sb)->mount_pending = 1;
528 
529         op_release(new_op);
530         return ret;
531 }
532 
533 void orangefs_make_bad_inode(struct inode *inode)
534 {
535         if (is_root_handle(inode)) {
536                 /*
537                  * if this occurs, the pvfs2-client-core was killed but we
538                  * can't afford to lose the inode operations and such
539                  * associated with the root handle in any case.
540                  */
541                 gossip_debug(GOSSIP_UTILS_DEBUG,
542                              "*** NOT making bad root inode %pU\n",
543                              get_khandle_from_ino(inode));
544         } else {
545                 gossip_debug(GOSSIP_UTILS_DEBUG,
546                              "*** making bad inode %pU\n",
547                              get_khandle_from_ino(inode));
548                 make_bad_inode(inode);
549         }
550 }
551 
552 /*
553  * The following is a very dirty hack that is now a permanent part of the
554  * ORANGEFS protocol. See protocol.h for more error definitions.
555  */
556 
557 /* The order matches include/orangefs-types.h in the OrangeFS source. */
558 static int PINT_errno_mapping[] = {
559         0, EPERM, ENOENT, EINTR, EIO, ENXIO, EBADF, EAGAIN, ENOMEM,
560         EFAULT, EBUSY, EEXIST, ENODEV, ENOTDIR, EISDIR, EINVAL, EMFILE,
561         EFBIG, ENOSPC, EROFS, EMLINK, EPIPE, EDEADLK, ENAMETOOLONG,
562         ENOLCK, ENOSYS, ENOTEMPTY, ELOOP, EWOULDBLOCK, ENOMSG, EUNATCH,
563         EBADR, EDEADLOCK, ENODATA, ETIME, ENONET, EREMOTE, ECOMM,
564         EPROTO, EBADMSG, EOVERFLOW, ERESTART, EMSGSIZE, EPROTOTYPE,
565         ENOPROTOOPT, EPROTONOSUPPORT, EOPNOTSUPP, EADDRINUSE,
566         EADDRNOTAVAIL, ENETDOWN, ENETUNREACH, ENETRESET, ENOBUFS,
567         ETIMEDOUT, ECONNREFUSED, EHOSTDOWN, EHOSTUNREACH, EALREADY,
568         EACCES, ECONNRESET, ERANGE
569 };
570 
571 int orangefs_normalize_to_errno(__s32 error_code)
572 {
573         __u32 i;
574 
575         /* Success */
576         if (error_code == 0) {
577                 return 0;
578         /*
579          * This shouldn't ever happen. If it does it should be fixed on the
580          * server.
581          */
582         } else if (error_code > 0) {
583                 gossip_err("orangefs: error status receieved.\n");
584                 gossip_err("orangefs: assuming error code is inverted.\n");
585                 error_code = -error_code;
586         }
587 
588         /*
589          * XXX: This is very bad since error codes from ORANGEFS may not be
590          * suitable for return into userspace.
591          */
592 
593         /*
594          * Convert ORANGEFS error values into errno values suitable for return
595          * from the kernel.
596          */
597         if ((-error_code) & ORANGEFS_NON_ERRNO_ERROR_BIT) {
598                 if (((-error_code) &
599                     (ORANGEFS_ERROR_NUMBER_BITS|ORANGEFS_NON_ERRNO_ERROR_BIT|
600                     ORANGEFS_ERROR_BIT)) == ORANGEFS_ECANCEL) {
601                         /*
602                          * cancellation error codes generally correspond to
603                          * a timeout from the client's perspective
604                          */
605                         error_code = -ETIMEDOUT;
606                 } else {
607                         /* assume a default error code */
608                         gossip_err("orangefs: warning: got error code without errno equivalent: %d.\n", error_code);
609                         error_code = -EINVAL;
610                 }
611 
612         /* Convert ORANGEFS encoded errno values into regular errno values. */
613         } else if ((-error_code) & ORANGEFS_ERROR_BIT) {
614                 i = (-error_code) & ~(ORANGEFS_ERROR_BIT|ORANGEFS_ERROR_CLASS_BITS);
615                 if (i < sizeof(PINT_errno_mapping)/sizeof(*PINT_errno_mapping))
616                         error_code = -PINT_errno_mapping[i];
617                 else
618                         error_code = -EINVAL;
619 
620         /*
621          * Only ORANGEFS protocol error codes should ever come here. Otherwise
622          * there is a bug somewhere.
623          */
624         } else {
625                 gossip_err("orangefs: orangefs_normalize_to_errno: got error code which is not from ORANGEFS.\n");
626         }
627         return error_code;
628 }
629 
630 #define NUM_MODES 11
631 __s32 ORANGEFS_util_translate_mode(int mode)
632 {
633         int ret = 0;
634         int i = 0;
635         static int modes[NUM_MODES] = {
636                 S_IXOTH, S_IWOTH, S_IROTH,
637                 S_IXGRP, S_IWGRP, S_IRGRP,
638                 S_IXUSR, S_IWUSR, S_IRUSR,
639                 S_ISGID, S_ISUID
640         };
641         static int orangefs_modes[NUM_MODES] = {
642                 ORANGEFS_O_EXECUTE, ORANGEFS_O_WRITE, ORANGEFS_O_READ,
643                 ORANGEFS_G_EXECUTE, ORANGEFS_G_WRITE, ORANGEFS_G_READ,
644                 ORANGEFS_U_EXECUTE, ORANGEFS_U_WRITE, ORANGEFS_U_READ,
645                 ORANGEFS_G_SGID, ORANGEFS_U_SUID
646         };
647 
648         for (i = 0; i < NUM_MODES; i++)
649                 if (mode & modes[i])
650                         ret |= orangefs_modes[i];
651 
652         return ret;
653 }
654 #undef NUM_MODES
655 
656 /*
657  * After obtaining a string representation of the client's debug
658  * keywords and their associated masks, this function is called to build an
659  * array of these values.
660  */
661 int orangefs_prepare_cdm_array(char *debug_array_string)
662 {
663         int i;
664         int rc = -EINVAL;
665         char *cds_head = NULL;
666         char *cds_delimiter = NULL;
667         int keyword_len = 0;
668 
669         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
670 
671         /*
672          * figure out how many elements the cdm_array needs.
673          */
674         for (i = 0; i < strlen(debug_array_string); i++)
675                 if (debug_array_string[i] == '\n')
676                         cdm_element_count++;
677 
678         if (!cdm_element_count) {
679                 pr_info("No elements in client debug array string!\n");
680                 goto out;
681         }
682 
683         cdm_array =
684                 kzalloc(cdm_element_count * sizeof(struct client_debug_mask),
685                         GFP_KERNEL);
686         if (!cdm_array) {
687                 pr_info("malloc failed for cdm_array!\n");
688                 rc = -ENOMEM;
689                 goto out;
690         }
691 
692         cds_head = debug_array_string;
693 
694         for (i = 0; i < cdm_element_count; i++) {
695                 cds_delimiter = strchr(cds_head, '\n');
696                 *cds_delimiter = '\0';
697 
698                 keyword_len = strcspn(cds_head, " ");
699 
700                 cdm_array[i].keyword = kzalloc(keyword_len + 1, GFP_KERNEL);
701                 if (!cdm_array[i].keyword) {
702                         rc = -ENOMEM;
703                         goto out;
704                 }
705 
706                 sscanf(cds_head,
707                        "%s %llx %llx",
708                        cdm_array[i].keyword,
709                        (unsigned long long *)&(cdm_array[i].mask1),
710                        (unsigned long long *)&(cdm_array[i].mask2));
711 
712                 if (!strcmp(cdm_array[i].keyword, ORANGEFS_VERBOSE))
713                         client_verbose_index = i;
714 
715                 if (!strcmp(cdm_array[i].keyword, ORANGEFS_ALL))
716                         client_all_index = i;
717 
718                 cds_head = cds_delimiter + 1;
719         }
720 
721         rc = cdm_element_count;
722 
723         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: rc:%d:\n", __func__, rc);
724 
725 out:
726 
727         return rc;
728 
729 }
730 
731 /*
732  * /sys/kernel/debug/orangefs/debug-help can be catted to
733  * see all the available kernel and client debug keywords.
734  *
735  * When the kernel boots, we have no idea what keywords the
736  * client supports, nor their associated masks.
737  *
738  * We pass through this function once at boot and stamp a
739  * boilerplate "we don't know" message for the client in the
740  * debug-help file. We pass through here again when the client
741  * starts and then we can fill out the debug-help file fully.
742  *
743  * The client might be restarted any number of times between
744  * reboots, we only build the debug-help file the first time.
745  */
746 int orangefs_prepare_debugfs_help_string(int at_boot)
747 {
748         int rc = -EINVAL;
749         int i;
750         int byte_count = 0;
751         char *client_title = "Client Debug Keywords:\n";
752         char *kernel_title = "Kernel Debug Keywords:\n";
753 
754         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
755 
756         if (at_boot) {
757                 byte_count += strlen(HELP_STRING_UNINITIALIZED);
758                 client_title = HELP_STRING_UNINITIALIZED;
759         } else {
760                 /*
761                  * fill the client keyword/mask array and remember
762                  * how many elements there were.
763                  */
764                 cdm_element_count =
765                         orangefs_prepare_cdm_array(client_debug_array_string);
766                 if (cdm_element_count <= 0)
767                         goto out;
768 
769                 /* Count the bytes destined for debug_help_string. */
770                 byte_count += strlen(client_title);
771 
772                 for (i = 0; i < cdm_element_count; i++) {
773                         byte_count += strlen(cdm_array[i].keyword + 2);
774                         if (byte_count >= DEBUG_HELP_STRING_SIZE) {
775                                 pr_info("%s: overflow 1!\n", __func__);
776                                 goto out;
777                         }
778                 }
779 
780                 gossip_debug(GOSSIP_UTILS_DEBUG,
781                              "%s: cdm_element_count:%d:\n",
782                              __func__,
783                              cdm_element_count);
784         }
785 
786         byte_count += strlen(kernel_title);
787         for (i = 0; i < num_kmod_keyword_mask_map; i++) {
788                 byte_count +=
789                         strlen(s_kmod_keyword_mask_map[i].keyword + 2);
790                 if (byte_count >= DEBUG_HELP_STRING_SIZE) {
791                         pr_info("%s: overflow 2!\n", __func__);
792                         goto out;
793                 }
794         }
795 
796         /* build debug_help_string. */
797         debug_help_string = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL);
798         if (!debug_help_string) {
799                 rc = -ENOMEM;
800                 goto out;
801         }
802 
803         strcat(debug_help_string, client_title);
804 
805         if (!at_boot) {
806                 for (i = 0; i < cdm_element_count; i++) {
807                         strcat(debug_help_string, "\t");
808                         strcat(debug_help_string, cdm_array[i].keyword);
809                         strcat(debug_help_string, "\n");
810                 }
811         }
812 
813         strcat(debug_help_string, "\n");
814         strcat(debug_help_string, kernel_title);
815 
816         for (i = 0; i < num_kmod_keyword_mask_map; i++) {
817                 strcat(debug_help_string, "\t");
818                 strcat(debug_help_string, s_kmod_keyword_mask_map[i].keyword);
819                 strcat(debug_help_string, "\n");
820         }
821 
822         rc = 0;
823 
824 out:
825 
826         return rc;
827 
828 }
829 
830 /*
831  * kernel = type 0
832  * client = type 1
833  */
834 void debug_mask_to_string(void *mask, int type)
835 {
836         int i;
837         int len = 0;
838         char *debug_string;
839         int element_count = 0;
840 
841         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
842 
843         if (type) {
844                 debug_string = client_debug_string;
845                 element_count = cdm_element_count;
846         } else {
847                 debug_string = kernel_debug_string;
848                 element_count = num_kmod_keyword_mask_map;
849         }
850 
851         memset(debug_string, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
852 
853         /*
854          * Some keywords, like "all" or "verbose", are amalgams of
855          * numerous other keywords. Make a special check for those
856          * before grinding through the whole mask only to find out
857          * later...
858          */
859         if (check_amalgam_keyword(mask, type))
860                 goto out;
861 
862         /* Build the debug string. */
863         for (i = 0; i < element_count; i++)
864                 if (type)
865                         do_c_string(mask, i);
866                 else
867                         do_k_string(mask, i);
868 
869         len = strlen(debug_string);
870 
871         if ((len) && (type))
872                 client_debug_string[len - 1] = '\0';
873         else if (len)
874                 kernel_debug_string[len - 1] = '\0';
875         else if (type)
876                 strcpy(client_debug_string, "none");
877         else
878                 strcpy(kernel_debug_string, "none");
879 
880 out:
881 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: string:%s:\n", __func__, debug_string);
882 
883         return;
884 
885 }
886 
887 void do_k_string(void *k_mask, int index)
888 {
889         __u64 *mask = (__u64 *) k_mask;
890 
891         if (keyword_is_amalgam((char *) s_kmod_keyword_mask_map[index].keyword))
892                 goto out;
893 
894         if (*mask & s_kmod_keyword_mask_map[index].mask_val) {
895                 if ((strlen(kernel_debug_string) +
896                      strlen(s_kmod_keyword_mask_map[index].keyword))
897                         < ORANGEFS_MAX_DEBUG_STRING_LEN - 1) {
898                                 strcat(kernel_debug_string,
899                                        s_kmod_keyword_mask_map[index].keyword);
900                                 strcat(kernel_debug_string, ",");
901                         } else {
902                                 gossip_err("%s: overflow!\n", __func__);
903                                 strcpy(kernel_debug_string, ORANGEFS_ALL);
904                                 goto out;
905                         }
906         }
907 
908 out:
909 
910         return;
911 }
912 
913 void do_c_string(void *c_mask, int index)
914 {
915         struct client_debug_mask *mask = (struct client_debug_mask *) c_mask;
916 
917         if (keyword_is_amalgam(cdm_array[index].keyword))
918                 goto out;
919 
920         if ((mask->mask1 & cdm_array[index].mask1) ||
921             (mask->mask2 & cdm_array[index].mask2)) {
922                 if ((strlen(client_debug_string) +
923                      strlen(cdm_array[index].keyword) + 1)
924                         < ORANGEFS_MAX_DEBUG_STRING_LEN - 2) {
925                                 strcat(client_debug_string,
926                                        cdm_array[index].keyword);
927                                 strcat(client_debug_string, ",");
928                         } else {
929                                 gossip_err("%s: overflow!\n", __func__);
930                                 strcpy(client_debug_string, ORANGEFS_ALL);
931                                 goto out;
932                         }
933         }
934 out:
935         return;
936 }
937 
938 int keyword_is_amalgam(char *keyword)
939 {
940         int rc = 0;
941 
942         if ((!strcmp(keyword, ORANGEFS_ALL)) || (!strcmp(keyword, ORANGEFS_VERBOSE)))
943                 rc = 1;
944 
945         return rc;
946 }
947 
948 /*
949  * kernel = type 0
950  * client = type 1
951  *
952  * return 1 if we found an amalgam.
953  */
954 int check_amalgam_keyword(void *mask, int type)
955 {
956         __u64 *k_mask;
957         struct client_debug_mask *c_mask;
958         int k_all_index = num_kmod_keyword_mask_map - 1;
959         int rc = 0;
960 
961         if (type) {
962                 c_mask = (struct client_debug_mask *) mask;
963 
964                 if ((c_mask->mask1 == cdm_array[client_all_index].mask1) &&
965                     (c_mask->mask2 == cdm_array[client_all_index].mask2)) {
966                         strcpy(client_debug_string, ORANGEFS_ALL);
967                         rc = 1;
968                         goto out;
969                 }
970 
971                 if ((c_mask->mask1 == cdm_array[client_verbose_index].mask1) &&
972                     (c_mask->mask2 == cdm_array[client_verbose_index].mask2)) {
973                         strcpy(client_debug_string, ORANGEFS_VERBOSE);
974                         rc = 1;
975                         goto out;
976                 }
977 
978         } else {
979                 k_mask = (__u64 *) mask;
980 
981                 if (*k_mask >= s_kmod_keyword_mask_map[k_all_index].mask_val) {
982                         strcpy(kernel_debug_string, ORANGEFS_ALL);
983                         rc = 1;
984                         goto out;
985                 }
986         }
987 
988 out:
989 
990         return rc;
991 }
992 
993 /*
994  * kernel = type 0
995  * client = type 1
996  */
997 void debug_string_to_mask(char *debug_string, void *mask, int type)
998 {
999         char *unchecked_keyword;
1000         int i;
1001         char *strsep_fodder = kstrdup(debug_string, GFP_KERNEL);
1002         char *original_pointer;
1003         int element_count = 0;
1004         struct client_debug_mask *c_mask;
1005         __u64 *k_mask;
1006 
1007         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
1008 
1009         if (type) {
1010                 c_mask = (struct client_debug_mask *)mask;
1011                 element_count = cdm_element_count;
1012         } else {
1013                 k_mask = (__u64 *)mask;
1014                 *k_mask = 0;
1015                 element_count = num_kmod_keyword_mask_map;
1016         }
1017 
1018         original_pointer = strsep_fodder;
1019         while ((unchecked_keyword = strsep(&strsep_fodder, ",")))
1020                 if (strlen(unchecked_keyword)) {
1021                         for (i = 0; i < element_count; i++)
1022                                 if (type)
1023                                         do_c_mask(i,
1024                                                   unchecked_keyword,
1025                                                   &c_mask);
1026                                 else
1027                                         do_k_mask(i,
1028                                                   unchecked_keyword,
1029                                                   &k_mask);
1030                 }
1031 
1032         kfree(original_pointer);
1033 }
1034 
1035 void do_c_mask(int i,
1036                char *unchecked_keyword,
1037                struct client_debug_mask **sane_mask)
1038 {
1039 
1040         if (!strcmp(cdm_array[i].keyword, unchecked_keyword)) {
1041                 (**sane_mask).mask1 = (**sane_mask).mask1 | cdm_array[i].mask1;
1042                 (**sane_mask).mask2 = (**sane_mask).mask2 | cdm_array[i].mask2;
1043         }
1044 }
1045 
1046 void do_k_mask(int i, char *unchecked_keyword, __u64 **sane_mask)
1047 {
1048 
1049         if (!strcmp(s_kmod_keyword_mask_map[i].keyword, unchecked_keyword))
1050                 **sane_mask = (**sane_mask) |
1051                                 s_kmod_keyword_mask_map[i].mask_val;
1052 }
1053 

~ [ 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