Lines Matching refs:req

374 		struct ceph_mds_request *req;
396 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS);
397 if (IS_ERR(req))
398 return PTR_ERR(req);
400 err = ceph_alloc_readdir_reply_buffer(req, inode);
402 ceph_mdsc_put_request(req);
406 req->r_direct_mode = USE_AUTH_MDS;
408 req->r_direct_hash = ceph_frag_value(frag);
409 __set_bit(CEPH_MDS_R_DIRECT_IS_HASH, &req->r_req_flags);
410 req->r_inode_drop = CEPH_CAP_FILE_EXCL;
416 req->r_path2 = kzalloc(NAME_MAX + 1, GFP_KERNEL);
417 if (!req->r_path2) {
418 ceph_mdsc_put_request(req);
423 req->r_path2);
425 ceph_mdsc_put_request(req);
429 req->r_args.readdir.offset_hash =
433 req->r_dir_release_cnt = dfi->dir_release_count;
434 req->r_dir_ordered_cnt = dfi->dir_ordered_count;
435 req->r_readdir_cache_idx = dfi->readdir_cache_idx;
436 req->r_readdir_offset = dfi->next_offset;
437 req->r_args.readdir.frag = cpu_to_le32(frag);
438 req->r_args.readdir.flags =
441 req->r_inode = inode;
443 req->r_dentry = dget(file->f_path.dentry);
444 err = ceph_mdsc_do_request(mdsc, NULL, req);
446 ceph_mdsc_put_request(req);
452 (int)req->r_reply_info.dir_end,
453 (int)req->r_reply_info.dir_complete,
454 (int)req->r_reply_info.hash_order);
456 rinfo = &req->r_reply_info;
460 dfi->next_offset = req->r_readdir_offset;
469 dfi->last_readdir = req;
471 if (test_bit(CEPH_MDS_R_DID_PREPOPULATE, &req->r_req_flags)) {
472 dfi->readdir_cache_idx = req->r_readdir_cache_idx;
480 dfi->dir_release_count = req->r_dir_release_cnt;
481 dfi->dir_ordered_count = req->r_dir_ordered_cnt;
495 unsigned next_offset = req->r_reply_info.dir_end ?
504 } else if (req->r_reply_info.dir_end) {
703 struct dentry *ceph_handle_snapdir(struct ceph_mds_request *req,
727 * Mainly, make sure we return the final req->r_dentry (if it already
735 struct dentry *ceph_finish_lookup(struct ceph_mds_request *req,
741 if (!req->r_reply_info.head->is_dentry) {
754 else if (dentry != req->r_dentry)
755 dentry = dget(req->r_dentry); /* we got spliced */
776 struct ceph_mds_request *req;
825 req = ceph_mdsc_create_request(mdsc, op, USE_ANY_MDS);
826 if (IS_ERR(req))
827 return ERR_CAST(req);
828 req->r_dentry = dget(dentry);
829 req->r_num_caps = 2;
834 req->r_args.getattr.mask = cpu_to_le32(mask);
837 req->r_parent = dir;
838 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags);
839 err = ceph_mdsc_do_request(mdsc, NULL, req);
843 res = ceph_handle_snapdir(req, dentry);
851 dentry = ceph_finish_lookup(req, dentry, err);
852 ceph_mdsc_put_request(req); /* will dput(dentry) */
888 struct ceph_mds_request *req;
906 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_MKNOD, USE_AUTH_MDS);
907 if (IS_ERR(req)) {
908 err = PTR_ERR(req);
912 req->r_new_inode = ceph_new_inode(dir, dentry, &mode, &as_ctx);
913 if (IS_ERR(req->r_new_inode)) {
914 err = PTR_ERR(req->r_new_inode);
915 req->r_new_inode = NULL;
920 set_bit(CEPH_MDS_R_FSCRYPT_FILE, &req->r_req_flags);
922 req->r_dentry = dget(dentry);
923 req->r_num_caps = 2;
924 req->r_parent = dir;
926 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags);
927 req->r_args.mknod.mode = cpu_to_le32(mode);
928 req->r_args.mknod.rdev = cpu_to_le32(rdev);
929 req->r_dentry_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_AUTH_EXCL |
931 req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
933 ceph_as_ctx_to_req(req, &as_ctx);
935 err = ceph_mdsc_do_request(mdsc, dir, req);
936 if (!err && !req->r_reply_info.head->is_dentry)
939 ceph_mdsc_put_request(req);
956 static int prep_encrypted_symlink_target(struct ceph_mds_request *req,
963 err = fscrypt_prepare_symlink(req->r_parent, dest, len, PATH_MAX,
968 err = fscrypt_encrypt_symlink(req->r_new_inode, dest, len, &osd_link);
972 req->r_path2 = kmalloc(CEPH_BASE64_CHARS(osd_link.len) + 1, GFP_KERNEL);
973 if (!req->r_path2) {
978 len = ceph_base64_encode(osd_link.name, osd_link.len, req->r_path2);
979 req->r_path2[len] = '\0';
985 static int prep_encrypted_symlink_target(struct ceph_mds_request *req,
996 struct ceph_mds_request *req;
1014 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SYMLINK, USE_AUTH_MDS);
1015 if (IS_ERR(req)) {
1016 err = PTR_ERR(req);
1020 req->r_new_inode = ceph_new_inode(dir, dentry, &mode, &as_ctx);
1021 if (IS_ERR(req->r_new_inode)) {
1022 err = PTR_ERR(req->r_new_inode);
1023 req->r_new_inode = NULL;
1027 req->r_parent = dir;
1030 if (IS_ENCRYPTED(req->r_new_inode)) {
1031 err = prep_encrypted_symlink_target(req, dest);
1035 req->r_path2 = kstrdup(dest, GFP_KERNEL);
1036 if (!req->r_path2) {
1042 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags);
1043 req->r_dentry = dget(dentry);
1044 req->r_num_caps = 2;
1045 req->r_dentry_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_AUTH_EXCL |
1047 req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
1049 ceph_as_ctx_to_req(req, &as_ctx);
1051 err = ceph_mdsc_do_request(mdsc, dir, req);
1052 if (!err && !req->r_reply_info.head->is_dentry)
1055 ceph_mdsc_put_request(req);
1067 struct ceph_mds_request *req;
1101 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS);
1102 if (IS_ERR(req)) {
1103 err = PTR_ERR(req);
1108 req->r_new_inode = ceph_new_inode(dir, dentry, &mode, &as_ctx);
1109 if (IS_ERR(req->r_new_inode)) {
1110 err = PTR_ERR(req->r_new_inode);
1111 req->r_new_inode = NULL;
1115 req->r_dentry = dget(dentry);
1116 req->r_num_caps = 2;
1117 req->r_parent = dir;
1119 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags);
1120 req->r_args.mkdir.mode = cpu_to_le32(mode);
1121 req->r_dentry_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_AUTH_EXCL |
1123 req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
1125 ceph_as_ctx_to_req(req, &as_ctx);
1127 err = ceph_mdsc_do_request(mdsc, dir, req);
1129 !req->r_reply_info.head->is_target &&
1130 !req->r_reply_info.head->is_dentry)
1133 ceph_mdsc_put_request(req);
1147 struct ceph_mds_request *req;
1166 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LINK, USE_AUTH_MDS);
1167 if (IS_ERR(req)) {
1169 return PTR_ERR(req);
1171 req->r_dentry = dget(dentry);
1172 req->r_num_caps = 2;
1173 req->r_old_dentry = dget(old_dentry);
1179 req->r_ino2 = ceph_vino(d_inode(old_dentry));
1180 req->r_parent = dir;
1182 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags);
1183 req->r_dentry_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_XATTR_EXCL;
1184 req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
1186 req->r_old_inode_drop = CEPH_CAP_LINK_SHARED | CEPH_CAP_LINK_EXCL;
1187 err = ceph_mdsc_do_request(mdsc, dir, req);
1190 } else if (!req->r_reply_info.head->is_dentry) {
1194 ceph_mdsc_put_request(req);
1199 struct ceph_mds_request *req)
1201 struct dentry *dentry = req->r_dentry;
1204 int result = req->r_err ? req->r_err :
1205 le32_to_cpu(req->r_reply_info.head->result);
1233 mapping_set_error(req->r_parent->i_mapping, result);
1234 ceph_dir_clear_complete(req->r_parent);
1241 mapping_set_error(req->r_old_inode->i_mapping, result);
1248 iput(req->r_old_inode);
1249 ceph_mdsc_release_dir_caps(req);
1296 struct ceph_mds_request *req;
1313 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS);
1314 if (IS_ERR(req)) {
1315 err = PTR_ERR(req);
1318 req->r_dentry = dget(dentry);
1319 req->r_num_caps = 2;
1320 req->r_parent = dir;
1322 req->r_dentry_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_XATTR_EXCL;
1323 req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
1324 req->r_inode_drop = ceph_drop_caps_for_unlink(inode);
1327 (req->r_dir_caps = get_caps_for_async_unlink(dir, dentry))) {
1332 ceph_cap_string(req->r_dir_caps));
1333 set_bit(CEPH_MDS_R_ASYNC, &req->r_req_flags);
1334 req->r_callback = ceph_async_unlink_cb;
1335 req->r_old_inode = d_inode(dentry);
1336 ihold(req->r_old_inode);
1347 err = ceph_mdsc_submit_request(mdsc, dir, req);
1366 ceph_mdsc_put_request(req);
1371 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags);
1372 err = ceph_mdsc_do_request(mdsc, dir, req);
1373 if (!err && !req->r_reply_info.head->is_dentry)
1377 ceph_mdsc_put_request(req);
1387 struct ceph_mds_request *req;
1418 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS);
1419 if (IS_ERR(req))
1420 return PTR_ERR(req);
1422 req->r_dentry = dget(new_dentry);
1423 req->r_num_caps = 2;
1424 req->r_old_dentry = dget(old_dentry);
1425 req->r_old_dentry_dir = old_dir;
1426 req->r_parent = new_dir;
1428 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags);
1429 req->r_old_dentry_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_XATTR_EXCL;
1430 req->r_old_dentry_unless = CEPH_CAP_FILE_EXCL;
1431 req->r_dentry_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_XATTR_EXCL;
1432 req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
1434 req->r_old_inode_drop = CEPH_CAP_LINK_SHARED | CEPH_CAP_LINK_EXCL;
1436 req->r_inode_drop =
1439 err = ceph_mdsc_do_request(mdsc, old_dir, req);
1440 if (!err && !req->r_reply_info.head->is_dentry) {
1448 ceph_mdsc_put_request(req);
1913 struct ceph_mds_request *req;
1924 req = ceph_mdsc_create_request(mdsc, op, USE_ANY_MDS);
1925 if (!IS_ERR(req)) {
1926 req->r_dentry = dget(dentry);
1927 req->r_num_caps = 2;
1928 req->r_parent = dir;
1934 req->r_args.getattr.mask = cpu_to_le32(mask);
1936 err = ceph_mdsc_do_request(mdsc, NULL, req);
1940 d_inode(dentry) == req->r_target_inode)
1950 ceph_mdsc_put_request(req);