int tiny_create(const char *path, mode_t mode, struct fuse_file_info *fi) { tiny_inode i_tmp; int target_inodeno; tiny_dentry *pDentry; char *token; char *path_copy; char *dir_name; char *base_name; int ino; int ret = 0; /* Get inode of the parent directory */ path_copy = (char*)malloc(strlen(path) + 1); strcpy(path_copy, path); dir_name = dirname(path_copy); token = strtok(dir_name, "/"); ReadInode(&i_tmp, tiny_superblk.s_rdirino); while (token) { pDentry = __find_dentry(&i_tmp, token); if (!pDentry || pDentry->type == FILE_TYPE_FILE) { ret = -ENOTDIR; goto err; } ReadInode(&i_tmp, pDentry->inodeNum); token = strtok(NULL, "/"); } /* Get dentry of the target */ free(path_copy); path_copy = (char*)malloc(strlen(path) + 1); strcpy(path_copy, path); base_name = basename(path_copy); if (strlen(base_name) > NAME_LEN_MAX - 1) { ret = -ENAMETOOLONG; goto err; } pDentry = __find_dentry(&i_tmp, base_name); /* There is no such file */ if (pDentry == NULL) { target_inodeno = __create_file(&i_tmp, base_name); if (target_inodeno < 0) { ret = -EDQUOT; goto err; } fi->fh = (uint64_t)target_inodeno; } else { ret = -EEXIST; goto err; } err: free(path_copy); return ret; }
/** * debugfs_create_file - create a file in the debugfs filesystem * @name: a pointer to a string containing the name of the file to create. * @mode: the permission that the file should have. * @parent: a pointer to the parent dentry for this file. This should be a * directory dentry if set. If this paramater is NULL, then the * file will be created in the root of the debugfs filesystem. * @data: a pointer to something that the caller will want to get to later * on. The inode.i_private pointer will point to this value on * the open() call. * @fops: a pointer to a struct file_operations that should be used for * this file. * * This is the basic "create a file" function for debugfs. It allows for a * wide range of flexibility in creating a file, or a directory (if you want * to create a directory, the debugfs_create_dir() function is * recommended to be used instead.) * * This function will return a pointer to a dentry if it succeeds. This * pointer must be passed to the debugfs_remove() function when the file is * to be removed (no automatic cleanup happens if your module is unloaded, * you are responsible here.) If an error occurs, %NULL will be returned. * * If debugfs is not enabled in the kernel, the value -%ENODEV will be * returned. */ struct dentry *debugfs_create_file(const char *name, umode_t mode, struct dentry *parent, void *data, const struct file_operations *fops) { switch (mode & S_IFMT) { case S_IFREG: case 0: break; default: BUG(); } return __create_file(name, mode, parent, data, fops); }
/** * debugfs_create_symlink- create a symbolic link in the debugfs filesystem * @name: a pointer to a string containing the name of the symbolic link to * create. * @parent: a pointer to the parent dentry for this symbolic link. This * should be a directory dentry if set. If this paramater is NULL, * then the symbolic link will be created in the root of the debugfs * filesystem. * @target: a pointer to a string containing the path to the target of the * symbolic link. * * This function creates a symbolic link with the given name in debugfs that * links to the given target path. * * This function will return a pointer to a dentry if it succeeds. This * pointer must be passed to the debugfs_remove() function when the symbolic * link is to be removed (no automatic cleanup happens if your module is * unloaded, you are responsible here.) If an error occurs, %NULL will be * returned. * * If debugfs is not enabled in the kernel, the value -%ENODEV will be * returned. */ struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent, const char *target) { struct dentry *result; char *link; link = kstrdup(target, GFP_KERNEL); if (!link) return NULL; result = __create_file(name, S_IFLNK | S_IRWXUGO, parent, link, NULL); if (!result) kfree(link); return result; }
/* * __wt_schema_create -- * Process a WT_SESSION::create operation for all supported types. */ int __wt_schema_create( WT_SESSION_IMPL *session, const char *uri, const char *config) { WT_CONFIG_ITEM cval; WT_DATA_SOURCE *dsrc; WT_DECL_RET; int exclusive; exclusive = ( __wt_config_getones(session, config, "exclusive", &cval) == 0 && cval.val != 0); /* * We track create operations: if we fail in the middle of creating a * complex object, we want to back it all out. */ WT_RET(__wt_meta_track_on(session)); if (WT_PREFIX_MATCH(uri, "colgroup:")) ret = __create_colgroup(session, uri, exclusive, config); else if (WT_PREFIX_MATCH(uri, "file:")) ret = __create_file(session, uri, exclusive, config); else if (WT_PREFIX_MATCH(uri, "lsm:")) ret = __wt_lsm_tree_create(session, uri, exclusive, config); else if (WT_PREFIX_MATCH(uri, "index:")) ret = __create_index(session, uri, exclusive, config); else if (WT_PREFIX_MATCH(uri, "table:")) ret = __create_table(session, uri, exclusive, config); else if ((dsrc = __wt_schema_get_source(session, uri)) != NULL) ret = dsrc->create == NULL ? __wt_object_unsupported(session, uri) : __create_data_source(session, uri, config, dsrc); else ret = __wt_bad_object_type(session, uri); session->dhandle = NULL; WT_TRET(__wt_meta_track_off(session, 1, ret != 0)); return (ret); }
/** * debugfs_create_dir - create a directory in the debugfs filesystem * @name: a pointer to a string containing the name of the directory to * create. * @parent: a pointer to the parent dentry for this file. This should be a * directory dentry if set. If this paramater is NULL, then the * directory will be created in the root of the debugfs filesystem. * * This function creates a directory in debugfs with the given name. * * This function will return a pointer to a dentry if it succeeds. This * pointer must be passed to the debugfs_remove() function when the file is * to be removed (no automatic cleanup happens if your module is unloaded, * you are responsible here.) If an error occurs, %NULL will be returned. * * If debugfs is not enabled in the kernel, the value -%ENODEV will be * returned. */ struct dentry *debugfs_create_dir(const char *name, struct dentry *parent) { return __create_file(name, S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO, parent, NULL, NULL); }