psdev.c

嵌入式系统设计与实例开发实验教材二源码 多线程应用程序设计 串行端口程序设计 AD接口实验 CAN总线通信实验 GPS通信实验 Linux内核移植与编译实验 IC卡读写实验 SD驱动使

                }
                path[input.path_len] = '\0';
                CDEBUG(D_PSDEV, "clear_all_fsetroot: path %s\n", path);

                upccom->uc_pid = current->pid;
                error = presto_clear_all_fsetroots(path);
                upccom->uc_pid = saved_pid;
                PRESTO_FREE(path, input.path_len + 1);
                EXIT;
                return error;
        }

        case PRESTO_GET_KMLSIZE: {
                int error;
                int saved_pid = upccom->uc_pid;
                char *path;
                size_t size = 0;
                struct {
                        __u64 size;
                        char *path;
                        int   path_len;
                } input;

                error = copy_from_user(&input, (char *)arg, sizeof(input));
                if ( error ) {
                        EXIT;
                        return error;
                }

                PRESTO_ALLOC(path, char *, input.path_len + 1);
                if ( !path ) {
                        EXIT;
                        return -ENOMEM;
                }
                error = copy_from_user(path, input.path, input.path_len);
                if ( error ) {
                        PRESTO_FREE(path, input.path_len + 1);
                        EXIT;
                        return error;
                }
                path[input.path_len] = '\0';
                CDEBUG(D_PSDEV, "get_kmlsize: len %d path %s\n", 
                       input.path_len, path);

                upccom->uc_pid = current->pid;
                error = presto_get_kmlsize(path, &size);
                PRESTO_FREE(path, input.path_len + 1);
                if (error) {
                        EXIT;
                        return error;
                }
                input.size = size;
                upccom->uc_pid = saved_pid;

                CDEBUG(D_PSDEV, "get_kmlsize: size = %Zd\n", size);

                EXIT;
                return copy_to_user((char *)arg, &input, sizeof(input));
        }

        case PRESTO_GET_RECNO: {
                int error;
                int saved_pid = upccom->uc_pid;
                char *path;
                off_t recno = 0;
                struct {
                        __u64 recno;
                        char *path;
                        int   path_len;
                } input;

                error = copy_from_user(&input, (char *)arg, sizeof(input));
                if ( error ) {
                        EXIT;
                        return error;
                }

                PRESTO_ALLOC(path, char *, input.path_len + 1);
                if ( !path ) {
                        EXIT;
                        return -ENOMEM;
                }
                error = copy_from_user(path, input.path, input.path_len);
                if ( error ) {
                        PRESTO_FREE(path, input.path_len + 1);
                        EXIT;
                        return error;
                }
                path[input.path_len] = '\0';
                CDEBUG(D_PSDEV, "get_recno: len %d path %s\n", 
                       input.path_len, path);

                upccom->uc_pid = current->pid;
                error = presto_get_lastrecno(path, &recno);
                PRESTO_FREE(path, input.path_len + 1);
                if (error) {
                        EXIT;
                        return error;
                }
                input.recno = recno;
                upccom->uc_pid = saved_pid;

                CDEBUG(D_PSDEV, "get_recno: recno = %d\n", (int) recno);

                EXIT;
                return copy_to_user((char *)arg, &input, sizeof(input));
        }

        case PRESTO_SET_FSETROOT: {
                /*
                 * Save information about the cache, and initialize "special"
                 * cache files (KML, etc).
                 */
                int error;
                int saved_pid = upccom->uc_pid;
                char *fsetname;
                char *path;
                struct {
                        char *path;
                        int   path_len;
                        char *name;
                        int   name_len;
                        int   id;
                        int   flags;
                } input;

                error = copy_from_user(&input, (char *)arg, sizeof(input));
                if ( error ) {
                        EXIT;
                        return error;
                }

                PRESTO_ALLOC(path, char *, input.path_len + 1);
                if ( !path ) {
                        EXIT;
                        return -ENOMEM;
                }
                error = copy_from_user(path, input.path, input.path_len);
                if ( error ) {
                        EXIT;
                        goto exit_free_path;
                }
                path[input.path_len] = '\0';

                PRESTO_ALLOC(fsetname, char *, input.name_len + 1);
                if ( !fsetname ) {
                        error = -ENOMEM;
                        EXIT;
                        goto exit_free_path;
                }
                error = copy_from_user(fsetname, input.name, input.name_len);
                if ( error ) {
                        EXIT;
                        goto exit_free_fsetname;
                }
                fsetname[input.name_len] = '\0';

                CDEBUG(D_PSDEV,
                       "set_fsetroot: path %s name %s, id %d, flags %x\n",
                       path, fsetname, input.id, input.flags);
                upccom->uc_pid = current->pid;
                error = presto_set_fsetroot(path, fsetname, input.id,input.flags);
                upccom->uc_pid = saved_pid;
                if ( error ) {
                        EXIT;
                        goto exit_free_fsetname;
                }
                /* fsetname is kept in the fset, so don't free it now */
                PRESTO_FREE(path, input.path_len + 1);
                EXIT;
                return 0;

        exit_free_fsetname:
                PRESTO_FREE(fsetname, input.name_len + 1);
        exit_free_path:
                PRESTO_FREE(path, input.path_len + 1);
                return error;
        }

        case PRESTO_CLOSE_JOURNALF: {
                int saved_pid = upccom->uc_pid;
                int error;

                CDEBUG(D_SUPER, "HELLO\n");

                /* pretend we are lento: we should lock something */
                upccom->uc_pid = current->pid;
                error = presto_close_journal_file(NULL);
                CDEBUG(D_PSDEV, "error is %d\n", error);
                upccom->uc_pid = saved_pid;
                EXIT;
                return error;
        }

        case PRESTO_GETOPT:
        case PRESTO_SETOPT: {
                /* return all the mounts for this device.  */
                int dosetopt(int, struct psdev_opt *);
                int dogetopt(int, struct psdev_opt *);
                int minor = 0;
                struct psdev_opt kopt;
                struct psdev_opt *user_opt = (struct psdev_opt *) arg;
                int error;

                error = copy_from_user(&kopt, (void *)arg, sizeof(kopt));
                if ( error )  {
                        printk("psdev: can't copyin %Zd bytes from %p to %p\n",
                               sizeof(kopt), (struct kopt *) arg, &kopt);
                        EXIT;
                        return error;
                }
                minor = MINOR(dev);
                if (cmd == PRESTO_SETOPT)
                        error = dosetopt(minor, &kopt);

                if ( error ) {
                        CDEBUG(D_PSDEV,
                               "dosetopt failed minor %d, opt %d, val %d\n",
                               minor, kopt.optname, kopt.optval);
                        EXIT;
                        return error;
                }

                error = dogetopt(minor, &kopt);

                if ( error ) {
                        CDEBUG(D_PSDEV,
                               "dogetopt failed minor %d, opt %d, val %d\n",
                               minor, kopt.optname, kopt.optval);
                        EXIT;
                        return error;
                }

                error = copy_to_user(user_opt, &kopt, sizeof(kopt));
                if ( error ) {
                        CDEBUG(D_PSDEV, "Copy_to_user opt 0x%p failed\n",
                               user_opt);
                        EXIT;
                        return error;
                }
                CDEBUG(D_PSDEV, "dosetopt minor %d, opt %d, val %d return %d\n",
                         minor, kopt.optname, kopt.optval, error);
                EXIT;
                return 0;
        }

        case PRESTO_VFS_SETATTR: {
                int error;
                struct lento_input_attr input;
                struct iattr iattr;

                error = copy_from_user(&input, (char *)arg, sizeof(input));
                if ( error ) {
                        EXIT;
                        return error;
                }
                iattr.ia_valid = input.valid;
                iattr.ia_mode  = (umode_t)input.mode;
                iattr.ia_uid   = (uid_t)input.uid;
                iattr.ia_gid   = (gid_t)input.gid;
                iattr.ia_size  = (off_t)input.size;
                iattr.ia_atime = (time_t)input.atime;
                iattr.ia_mtime = (time_t)input.mtime;
                iattr.ia_ctime = (time_t)input.ctime;
                iattr.ia_attr_flags = input.attr_flags;

                error = lento_setattr(input.name, &iattr, &input.info);
                EXIT;
                return error;
        }

        case PRESTO_VFS_CREATE: {
                int error;
                struct lento_input_mode input;

                error = copy_from_user(&input, (char *)arg, sizeof(input));
                if ( error ) {
                        EXIT;
                        return error;
                }

                error = lento_create(input.name, input.mode, &input.info);
                EXIT;
                return error;
        }

        case PRESTO_VFS_LINK: {
                int error;
                struct lento_input_old_new input;

                error = copy_from_user(&input, (char *)arg, sizeof(input));
                if ( error ) {
                        EXIT;
                        return error;
                }

                error = lento_link(input.oldname, input.newname, &input.info);
                EXIT;
                return error;
        }

        case PRESTO_VFS_UNLINK: {
                int error;
                struct lento_input input;

                error = copy_from_user(&input, (char *)arg, sizeof(input));
                if ( error ) {
                        EXIT;
                        return error;
                }

                error = lento_unlink(input.name, &input.info);
                EXIT;
                return error;
        }

        case PRESTO_VFS_SYMLINK: {
                int error;
                struct lento_input_old_new input;

                error = copy_from_user(&input, (char *)arg, sizeof(input));
                if ( error ) {
                        EXIT;
                        return error;
                }

                error = lento_symlink(input.oldname, input.newname,&input.info);
                EXIT;
                return error;
        }

        case PRESTO_VFS_MKDIR: {
                int error;
                struct lento_input_mode input;

                error = copy_from_user(&input, (char *)arg, sizeof(input));
                if ( error ) {
                        EXIT;
                        return error;
                }

                error = lento_mkdir(input.name, input.mode, &input.info);
                EXIT;
                return error;
        }

        case PRESTO_VFS_RMDIR: {
                int error;
                struct lento_input input;

                error = copy_from_user(&input, (char *)arg, sizeof(input));
                if ( error ) {
                        EXIT;
                        return error;
                }

                error = lento_rmdir(input.name, &input.info);
                EXIT;
                return error;
        }

        case PRESTO_VFS_MKNOD: {
                int error;
                struct lento_input_dev input;

                error = copy_from_user(&input, (char *)arg, sizeof(input));
                if ( error ) {
                        EXIT;
                        return error;
                }

                error = lento_mknod(input.name, input.mode,
                                    MKDEV(input.major,input.minor),&input.info);
                EXIT;
                return error;
        }

        case PRESTO_VFS_RENAME: {
                int error;
                struct lento_input_old_new input;

                error = copy_from_user(&input, (char *)arg, sizeof(input));
                if ( error ) {
                        EXIT;
                        return error;
                }

                error = lento_rename(input.oldname, input.newname, &input.info);
                EXIT;
                return error;
        }

#ifdef CONFIG_FS_EXT_ATTR
        /* IOCTL to create/modify an extended attribute */
        case PRESTO_VFS_SETEXTATTR: {
                int error;
                struct lento_input_ext_attr input;
                char *name;
                char *buffer;

                error = copy_from_user(&input, (char *)arg, sizeof(input));
                if ( error ) { 
                    EXIT;
                    return error;
                }

                /* Now setup the input parameters */
                PRESTO_ALLOC(name, char *, input.name_len+1);
                /* We need null terminated strings for attr names */
                name[input.name_len] = '\0';
                error=copy_from_user(name, input.name, input.name_len);
                if ( error ) { 
                    EXIT;
                    PRESTO_FREE(name,input.name_len+1);
                    return error;
                }