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

TOMOYO Linux Cross Reference
Linux/fs/fuse/cuse.c

Version: ~ [ linux-5.2-rc1 ] ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ 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  * CUSE: Character device in Userspace
  3  *
  4  * Copyright (C) 2008-2009  SUSE Linux Products GmbH
  5  * Copyright (C) 2008-2009  Tejun Heo <tj@kernel.org>
  6  *
  7  * This file is released under the GPLv2.
  8  *
  9  * CUSE enables character devices to be implemented from userland much
 10  * like FUSE allows filesystems.  On initialization /dev/cuse is
 11  * created.  By opening the file and replying to the CUSE_INIT request
 12  * userland CUSE server can create a character device.  After that the
 13  * operation is very similar to FUSE.
 14  *
 15  * A CUSE instance involves the following objects.
 16  *
 17  * cuse_conn    : contains fuse_conn and serves as bonding structure
 18  * channel      : file handle connected to the userland CUSE server
 19  * cdev         : the implemented character device
 20  * dev          : generic device for cdev
 21  *
 22  * Note that 'channel' is what 'dev' is in FUSE.  As CUSE deals with
 23  * devices, it's called 'channel' to reduce confusion.
 24  *
 25  * channel determines when the character device dies.  When channel is
 26  * closed, everything begins to destruct.  The cuse_conn is taken off
 27  * the lookup table preventing further access from cdev, cdev and
 28  * generic device are removed and the base reference of cuse_conn is
 29  * put.
 30  *
 31  * On each open, the matching cuse_conn is looked up and if found an
 32  * additional reference is taken which is released when the file is
 33  * closed.
 34  */
 35 
 36 #include <linux/fuse.h>
 37 #include <linux/cdev.h>
 38 #include <linux/device.h>
 39 #include <linux/file.h>
 40 #include <linux/fs.h>
 41 #include <linux/kdev_t.h>
 42 #include <linux/kthread.h>
 43 #include <linux/list.h>
 44 #include <linux/magic.h>
 45 #include <linux/miscdevice.h>
 46 #include <linux/mutex.h>
 47 #include <linux/slab.h>
 48 #include <linux/stat.h>
 49 #include <linux/module.h>
 50 #include <linux/uio.h>
 51 
 52 #include "fuse_i.h"
 53 
 54 #define CUSE_CONNTBL_LEN        64
 55 
 56 struct cuse_conn {
 57         struct list_head        list;   /* linked on cuse_conntbl */
 58         struct fuse_conn        fc;     /* fuse connection */
 59         struct cdev             *cdev;  /* associated character device */
 60         struct device           *dev;   /* device representing @cdev */
 61 
 62         /* init parameters, set once during initialization */
 63         bool                    unrestricted_ioctl;
 64 };
 65 
 66 static DEFINE_MUTEX(cuse_lock);         /* protects registration */
 67 static struct list_head cuse_conntbl[CUSE_CONNTBL_LEN];
 68 static struct class *cuse_class;
 69 
 70 static struct cuse_conn *fc_to_cc(struct fuse_conn *fc)
 71 {
 72         return container_of(fc, struct cuse_conn, fc);
 73 }
 74 
 75 static struct list_head *cuse_conntbl_head(dev_t devt)
 76 {
 77         return &cuse_conntbl[(MAJOR(devt) + MINOR(devt)) % CUSE_CONNTBL_LEN];
 78 }
 79 
 80 
 81 /**************************************************************************
 82  * CUSE frontend operations
 83  *
 84  * These are file operations for the character device.
 85  *
 86  * On open, CUSE opens a file from the FUSE mnt and stores it to
 87  * private_data of the open file.  All other ops call FUSE ops on the
 88  * FUSE file.
 89  */
 90 
 91 static ssize_t cuse_read_iter(struct kiocb *kiocb, struct iov_iter *to)
 92 {
 93         struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(kiocb->ki_filp);
 94         loff_t pos = 0;
 95 
 96         return fuse_direct_io(&io, to, &pos, FUSE_DIO_CUSE);
 97 }
 98 
 99 static ssize_t cuse_write_iter(struct kiocb *kiocb, struct iov_iter *from)
100 {
101         struct fuse_io_priv io = FUSE_IO_PRIV_SYNC(kiocb->ki_filp);
102         loff_t pos = 0;
103         /*
104          * No locking or generic_write_checks(), the server is
105          * responsible for locking and sanity checks.
106          */
107         return fuse_direct_io(&io, from, &pos,
108                               FUSE_DIO_WRITE | FUSE_DIO_CUSE);
109 }
110 
111 static int cuse_open(struct inode *inode, struct file *file)
112 {
113         dev_t devt = inode->i_cdev->dev;
114         struct cuse_conn *cc = NULL, *pos;
115         int rc;
116 
117         /* look up and get the connection */
118         mutex_lock(&cuse_lock);
119         list_for_each_entry(pos, cuse_conntbl_head(devt), list)
120                 if (pos->dev->devt == devt) {
121                         fuse_conn_get(&pos->fc);
122                         cc = pos;
123                         break;
124                 }
125         mutex_unlock(&cuse_lock);
126 
127         /* dead? */
128         if (!cc)
129                 return -ENODEV;
130 
131         /*
132          * Generic permission check is already done against the chrdev
133          * file, proceed to open.
134          */
135         rc = fuse_do_open(&cc->fc, 0, file, 0);
136         if (rc)
137                 fuse_conn_put(&cc->fc);
138         return rc;
139 }
140 
141 static int cuse_release(struct inode *inode, struct file *file)
142 {
143         struct fuse_file *ff = file->private_data;
144         struct fuse_conn *fc = ff->fc;
145 
146         fuse_sync_release(ff, file->f_flags);
147         fuse_conn_put(fc);
148 
149         return 0;
150 }
151 
152 static long cuse_file_ioctl(struct file *file, unsigned int cmd,
153                             unsigned long arg)
154 {
155         struct fuse_file *ff = file->private_data;
156         struct cuse_conn *cc = fc_to_cc(ff->fc);
157         unsigned int flags = 0;
158 
159         if (cc->unrestricted_ioctl)
160                 flags |= FUSE_IOCTL_UNRESTRICTED;
161 
162         return fuse_do_ioctl(file, cmd, arg, flags);
163 }
164 
165 static long cuse_file_compat_ioctl(struct file *file, unsigned int cmd,
166                                    unsigned long arg)
167 {
168         struct fuse_file *ff = file->private_data;
169         struct cuse_conn *cc = fc_to_cc(ff->fc);
170         unsigned int flags = FUSE_IOCTL_COMPAT;
171 
172         if (cc->unrestricted_ioctl)
173                 flags |= FUSE_IOCTL_UNRESTRICTED;
174 
175         return fuse_do_ioctl(file, cmd, arg, flags);
176 }
177 
178 static const struct file_operations cuse_frontend_fops = {
179         .owner                  = THIS_MODULE,
180         .read_iter              = cuse_read_iter,
181         .write_iter             = cuse_write_iter,
182         .open                   = cuse_open,
183         .release                = cuse_release,
184         .unlocked_ioctl         = cuse_file_ioctl,
185         .compat_ioctl           = cuse_file_compat_ioctl,
186         .poll                   = fuse_file_poll,
187         .llseek         = noop_llseek,
188 };
189 
190 
191 /**************************************************************************
192  * CUSE channel initialization and destruction
193  */
194 
195 struct cuse_devinfo {
196         const char              *name;
197 };
198 
199 /**
200  * cuse_parse_one - parse one key=value pair
201  * @pp: i/o parameter for the current position
202  * @end: points to one past the end of the packed string
203  * @keyp: out parameter for key
204  * @valp: out parameter for value
205  *
206  * *@pp points to packed strings - "key0=val0\0key1=val1\0" which ends
207  * at @end - 1.  This function parses one pair and set *@keyp to the
208  * start of the key and *@valp to the start of the value.  Note that
209  * the original string is modified such that the key string is
210  * terminated with '\0'.  *@pp is updated to point to the next string.
211  *
212  * RETURNS:
213  * 1 on successful parse, 0 on EOF, -errno on failure.
214  */
215 static int cuse_parse_one(char **pp, char *end, char **keyp, char **valp)
216 {
217         char *p = *pp;
218         char *key, *val;
219 
220         while (p < end && *p == '\0')
221                 p++;
222         if (p == end)
223                 return 0;
224 
225         if (end[-1] != '\0') {
226                 printk(KERN_ERR "CUSE: info not properly terminated\n");
227                 return -EINVAL;
228         }
229 
230         key = val = p;
231         p += strlen(p);
232 
233         if (valp) {
234                 strsep(&val, "=");
235                 if (!val)
236                         val = key + strlen(key);
237                 key = strstrip(key);
238                 val = strstrip(val);
239         } else
240                 key = strstrip(key);
241 
242         if (!strlen(key)) {
243                 printk(KERN_ERR "CUSE: zero length info key specified\n");
244                 return -EINVAL;
245         }
246 
247         *pp = p;
248         *keyp = key;
249         if (valp)
250                 *valp = val;
251 
252         return 1;
253 }
254 
255 /**
256  * cuse_parse_dev_info - parse device info
257  * @p: device info string
258  * @len: length of device info string
259  * @devinfo: out parameter for parsed device info
260  *
261  * Parse @p to extract device info and store it into @devinfo.  String
262  * pointed to by @p is modified by parsing and @devinfo points into
263  * them, so @p shouldn't be freed while @devinfo is in use.
264  *
265  * RETURNS:
266  * 0 on success, -errno on failure.
267  */
268 static int cuse_parse_devinfo(char *p, size_t len, struct cuse_devinfo *devinfo)
269 {
270         char *end = p + len;
271         char *uninitialized_var(key), *uninitialized_var(val);
272         int rc;
273 
274         while (true) {
275                 rc = cuse_parse_one(&p, end, &key, &val);
276                 if (rc < 0)
277                         return rc;
278                 if (!rc)
279                         break;
280                 if (strcmp(key, "DEVNAME") == 0)
281                         devinfo->name = val;
282                 else
283                         printk(KERN_WARNING "CUSE: unknown device info \"%s\"\n",
284                                key);
285         }
286 
287         if (!devinfo->name || !strlen(devinfo->name)) {
288                 printk(KERN_ERR "CUSE: DEVNAME unspecified\n");
289                 return -EINVAL;
290         }
291 
292         return 0;
293 }
294 
295 static void cuse_gendev_release(struct device *dev)
296 {
297         kfree(dev);
298 }
299 
300 /**
301  * cuse_process_init_reply - finish initializing CUSE channel
302  *
303  * This function creates the character device and sets up all the
304  * required data structures for it.  Please read the comment at the
305  * top of this file for high level overview.
306  */
307 static void cuse_process_init_reply(struct fuse_conn *fc, struct fuse_req *req)
308 {
309         struct cuse_conn *cc = fc_to_cc(fc), *pos;
310         struct cuse_init_out *arg = req->out.args[0].value;
311         struct page *page = req->pages[0];
312         struct cuse_devinfo devinfo = { };
313         struct device *dev;
314         struct cdev *cdev;
315         dev_t devt;
316         int rc, i;
317 
318         if (req->out.h.error ||
319             arg->major != FUSE_KERNEL_VERSION || arg->minor < 11) {
320                 goto err;
321         }
322 
323         fc->minor = arg->minor;
324         fc->max_read = max_t(unsigned, arg->max_read, 4096);
325         fc->max_write = max_t(unsigned, arg->max_write, 4096);
326 
327         /* parse init reply */
328         cc->unrestricted_ioctl = arg->flags & CUSE_UNRESTRICTED_IOCTL;
329 
330         rc = cuse_parse_devinfo(page_address(page), req->out.args[1].size,
331                                 &devinfo);
332         if (rc)
333                 goto err;
334 
335         /* determine and reserve devt */
336         devt = MKDEV(arg->dev_major, arg->dev_minor);
337         if (!MAJOR(devt))
338                 rc = alloc_chrdev_region(&devt, MINOR(devt), 1, devinfo.name);
339         else
340                 rc = register_chrdev_region(devt, 1, devinfo.name);
341         if (rc) {
342                 printk(KERN_ERR "CUSE: failed to register chrdev region\n");
343                 goto err;
344         }
345 
346         /* devt determined, create device */
347         rc = -ENOMEM;
348         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
349         if (!dev)
350                 goto err_region;
351 
352         device_initialize(dev);
353         dev_set_uevent_suppress(dev, 1);
354         dev->class = cuse_class;
355         dev->devt = devt;
356         dev->release = cuse_gendev_release;
357         dev_set_drvdata(dev, cc);
358         dev_set_name(dev, "%s", devinfo.name);
359 
360         mutex_lock(&cuse_lock);
361 
362         /* make sure the device-name is unique */
363         for (i = 0; i < CUSE_CONNTBL_LEN; ++i) {
364                 list_for_each_entry(pos, &cuse_conntbl[i], list)
365                         if (!strcmp(dev_name(pos->dev), dev_name(dev)))
366                                 goto err_unlock;
367         }
368 
369         rc = device_add(dev);
370         if (rc)
371                 goto err_unlock;
372 
373         /* register cdev */
374         rc = -ENOMEM;
375         cdev = cdev_alloc();
376         if (!cdev)
377                 goto err_unlock;
378 
379         cdev->owner = THIS_MODULE;
380         cdev->ops = &cuse_frontend_fops;
381 
382         rc = cdev_add(cdev, devt, 1);
383         if (rc)
384                 goto err_cdev;
385 
386         cc->dev = dev;
387         cc->cdev = cdev;
388 
389         /* make the device available */
390         list_add(&cc->list, cuse_conntbl_head(devt));
391         mutex_unlock(&cuse_lock);
392 
393         /* announce device availability */
394         dev_set_uevent_suppress(dev, 0);
395         kobject_uevent(&dev->kobj, KOBJ_ADD);
396 out:
397         kfree(arg);
398         __free_page(page);
399         return;
400 
401 err_cdev:
402         cdev_del(cdev);
403 err_unlock:
404         mutex_unlock(&cuse_lock);
405         put_device(dev);
406 err_region:
407         unregister_chrdev_region(devt, 1);
408 err:
409         fuse_abort_conn(fc);
410         goto out;
411 }
412 
413 static int cuse_send_init(struct cuse_conn *cc)
414 {
415         int rc;
416         struct fuse_req *req;
417         struct page *page;
418         struct fuse_conn *fc = &cc->fc;
419         struct cuse_init_in *arg;
420         void *outarg;
421 
422         BUILD_BUG_ON(CUSE_INIT_INFO_MAX > PAGE_SIZE);
423 
424         req = fuse_get_req_for_background(fc, 1);
425         if (IS_ERR(req)) {
426                 rc = PTR_ERR(req);
427                 goto err;
428         }
429 
430         rc = -ENOMEM;
431         page = alloc_page(GFP_KERNEL | __GFP_ZERO);
432         if (!page)
433                 goto err_put_req;
434 
435         outarg = kzalloc(sizeof(struct cuse_init_out), GFP_KERNEL);
436         if (!outarg)
437                 goto err_free_page;
438 
439         arg = &req->misc.cuse_init_in;
440         arg->major = FUSE_KERNEL_VERSION;
441         arg->minor = FUSE_KERNEL_MINOR_VERSION;
442         arg->flags |= CUSE_UNRESTRICTED_IOCTL;
443         req->in.h.opcode = CUSE_INIT;
444         req->in.numargs = 1;
445         req->in.args[0].size = sizeof(struct cuse_init_in);
446         req->in.args[0].value = arg;
447         req->out.numargs = 2;
448         req->out.args[0].size = sizeof(struct cuse_init_out);
449         req->out.args[0].value = outarg;
450         req->out.args[1].size = CUSE_INIT_INFO_MAX;
451         req->out.argvar = 1;
452         req->out.argpages = 1;
453         req->pages[0] = page;
454         req->page_descs[0].length = req->out.args[1].size;
455         req->num_pages = 1;
456         req->end = cuse_process_init_reply;
457         fuse_request_send_background(fc, req);
458 
459         return 0;
460 
461 err_free_page:
462         __free_page(page);
463 err_put_req:
464         fuse_put_request(fc, req);
465 err:
466         return rc;
467 }
468 
469 static void cuse_fc_release(struct fuse_conn *fc)
470 {
471         struct cuse_conn *cc = fc_to_cc(fc);
472         kfree_rcu(cc, fc.rcu);
473 }
474 
475 /**
476  * cuse_channel_open - open method for /dev/cuse
477  * @inode: inode for /dev/cuse
478  * @file: file struct being opened
479  *
480  * Userland CUSE server can create a CUSE device by opening /dev/cuse
481  * and replying to the initialization request kernel sends.  This
482  * function is responsible for handling CUSE device initialization.
483  * Because the fd opened by this function is used during
484  * initialization, this function only creates cuse_conn and sends
485  * init.  The rest is delegated to a kthread.
486  *
487  * RETURNS:
488  * 0 on success, -errno on failure.
489  */
490 static int cuse_channel_open(struct inode *inode, struct file *file)
491 {
492         struct fuse_dev *fud;
493         struct cuse_conn *cc;
494         int rc;
495 
496         /* set up cuse_conn */
497         cc = kzalloc(sizeof(*cc), GFP_KERNEL);
498         if (!cc)
499                 return -ENOMEM;
500 
501         fuse_conn_init(&cc->fc);
502 
503         fud = fuse_dev_alloc(&cc->fc);
504         if (!fud) {
505                 kfree(cc);
506                 return -ENOMEM;
507         }
508 
509         INIT_LIST_HEAD(&cc->list);
510         cc->fc.release = cuse_fc_release;
511 
512         cc->fc.initialized = 1;
513         rc = cuse_send_init(cc);
514         if (rc) {
515                 fuse_dev_free(fud);
516                 return rc;
517         }
518         file->private_data = fud;
519 
520         return 0;
521 }
522 
523 /**
524  * cuse_channel_release - release method for /dev/cuse
525  * @inode: inode for /dev/cuse
526  * @file: file struct being closed
527  *
528  * Disconnect the channel, deregister CUSE device and initiate
529  * destruction by putting the default reference.
530  *
531  * RETURNS:
532  * 0 on success, -errno on failure.
533  */
534 static int cuse_channel_release(struct inode *inode, struct file *file)
535 {
536         struct fuse_dev *fud = file->private_data;
537         struct cuse_conn *cc = fc_to_cc(fud->fc);
538         int rc;
539 
540         /* remove from the conntbl, no more access from this point on */
541         mutex_lock(&cuse_lock);
542         list_del_init(&cc->list);
543         mutex_unlock(&cuse_lock);
544 
545         /* remove device */
546         if (cc->dev)
547                 device_unregister(cc->dev);
548         if (cc->cdev) {
549                 unregister_chrdev_region(cc->cdev->dev, 1);
550                 cdev_del(cc->cdev);
551         }
552         /* Base reference is now owned by "fud" */
553         fuse_conn_put(&cc->fc);
554 
555         rc = fuse_dev_release(inode, file);     /* puts the base reference */
556 
557         return rc;
558 }
559 
560 static struct file_operations cuse_channel_fops; /* initialized during init */
561 
562 
563 /**************************************************************************
564  * Misc stuff and module initializatiion
565  *
566  * CUSE exports the same set of attributes to sysfs as fusectl.
567  */
568 
569 static ssize_t cuse_class_waiting_show(struct device *dev,
570                                        struct device_attribute *attr, char *buf)
571 {
572         struct cuse_conn *cc = dev_get_drvdata(dev);
573 
574         return sprintf(buf, "%d\n", atomic_read(&cc->fc.num_waiting));
575 }
576 static DEVICE_ATTR(waiting, 0400, cuse_class_waiting_show, NULL);
577 
578 static ssize_t cuse_class_abort_store(struct device *dev,
579                                       struct device_attribute *attr,
580                                       const char *buf, size_t count)
581 {
582         struct cuse_conn *cc = dev_get_drvdata(dev);
583 
584         fuse_abort_conn(&cc->fc);
585         return count;
586 }
587 static DEVICE_ATTR(abort, 0200, NULL, cuse_class_abort_store);
588 
589 static struct attribute *cuse_class_dev_attrs[] = {
590         &dev_attr_waiting.attr,
591         &dev_attr_abort.attr,
592         NULL,
593 };
594 ATTRIBUTE_GROUPS(cuse_class_dev);
595 
596 static struct miscdevice cuse_miscdev = {
597         .minor          = CUSE_MINOR,
598         .name           = "cuse",
599         .fops           = &cuse_channel_fops,
600 };
601 
602 MODULE_ALIAS_MISCDEV(CUSE_MINOR);
603 MODULE_ALIAS("devname:cuse");
604 
605 static int __init cuse_init(void)
606 {
607         int i, rc;
608 
609         /* init conntbl */
610         for (i = 0; i < CUSE_CONNTBL_LEN; i++)
611                 INIT_LIST_HEAD(&cuse_conntbl[i]);
612 
613         /* inherit and extend fuse_dev_operations */
614         cuse_channel_fops               = fuse_dev_operations;
615         cuse_channel_fops.owner         = THIS_MODULE;
616         cuse_channel_fops.open          = cuse_channel_open;
617         cuse_channel_fops.release       = cuse_channel_release;
618 
619         cuse_class = class_create(THIS_MODULE, "cuse");
620         if (IS_ERR(cuse_class))
621                 return PTR_ERR(cuse_class);
622 
623         cuse_class->dev_groups = cuse_class_dev_groups;
624 
625         rc = misc_register(&cuse_miscdev);
626         if (rc) {
627                 class_destroy(cuse_class);
628                 return rc;
629         }
630 
631         return 0;
632 }
633 
634 static void __exit cuse_exit(void)
635 {
636         misc_deregister(&cuse_miscdev);
637         class_destroy(cuse_class);
638 }
639 
640 module_init(cuse_init);
641 module_exit(cuse_exit);
642 
643 MODULE_AUTHOR("Tejun Heo <tj@kernel.org>");
644 MODULE_DESCRIPTION("Character device in Userspace");
645 MODULE_LICENSE("GPL");
646 

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