3 #include "bkey_methods.h"
4 #include "btree_update.h"
11 #include <linux/dcache.h>
13 unsigned bch2_dirent_name_bytes(struct bkey_s_c_dirent d)
15 unsigned len = bkey_val_bytes(d.k) -
16 offsetof(struct bch_dirent, d_name);
18 return strnlen(d.v->d_name, len);
21 static u64 bch2_dirent_hash(const struct bch_hash_info *info,
22 const struct qstr *name)
24 struct bch_str_hash_ctx ctx;
26 bch2_str_hash_init(&ctx, info);
27 bch2_str_hash_update(&ctx, info, name->name, name->len);
29 /* [0,2) reserved for dots */
30 return max_t(u64, bch2_str_hash_end(&ctx, info), 2);
33 static u64 dirent_hash_key(const struct bch_hash_info *info, const void *key)
35 return bch2_dirent_hash(info, key);
38 static u64 dirent_hash_bkey(const struct bch_hash_info *info, struct bkey_s_c k)
40 struct bkey_s_c_dirent d = bkey_s_c_to_dirent(k);
41 struct qstr name = QSTR_INIT(d.v->d_name, bch2_dirent_name_bytes(d));
43 return bch2_dirent_hash(info, &name);
46 static bool dirent_cmp_key(struct bkey_s_c _l, const void *_r)
48 struct bkey_s_c_dirent l = bkey_s_c_to_dirent(_l);
49 int len = bch2_dirent_name_bytes(l);
50 const struct qstr *r = _r;
52 return len - r->len ?: memcmp(l.v->d_name, r->name, len);
55 static bool dirent_cmp_bkey(struct bkey_s_c _l, struct bkey_s_c _r)
57 struct bkey_s_c_dirent l = bkey_s_c_to_dirent(_l);
58 struct bkey_s_c_dirent r = bkey_s_c_to_dirent(_r);
59 int l_len = bch2_dirent_name_bytes(l);
60 int r_len = bch2_dirent_name_bytes(r);
62 return l_len - r_len ?: memcmp(l.v->d_name, r.v->d_name, l_len);
65 const struct bch_hash_desc bch2_dirent_hash_desc = {
66 .btree_id = BTREE_ID_DIRENTS,
67 .key_type = KEY_TYPE_dirent,
68 .hash_key = dirent_hash_key,
69 .hash_bkey = dirent_hash_bkey,
70 .cmp_key = dirent_cmp_key,
71 .cmp_bkey = dirent_cmp_bkey,
74 const char *bch2_dirent_invalid(const struct bch_fs *c, struct bkey_s_c k)
76 struct bkey_s_c_dirent d = bkey_s_c_to_dirent(k);
79 if (bkey_val_bytes(k.k) < sizeof(struct bch_dirent))
80 return "value too small";
82 len = bch2_dirent_name_bytes(d);
87 * older versions of bcachefs were buggy and creating dirent
88 * keys that were bigger than necessary:
90 if (bkey_val_u64s(k.k) > dirent_val_u64s(len + 7))
91 return "value too big";
93 if (len > BCH_NAME_MAX)
94 return "dirent name too big";
99 void bch2_dirent_to_text(struct printbuf *out, struct bch_fs *c,
102 struct bkey_s_c_dirent d = bkey_s_c_to_dirent(k);
104 bch_scnmemcpy(out, d.v->d_name,
105 bch2_dirent_name_bytes(d));
106 pr_buf(out, " -> %llu", d.v->d_inum);
109 static struct bkey_i_dirent *dirent_create_key(struct btree_trans *trans,
110 u8 type, const struct qstr *name, u64 dst)
112 struct bkey_i_dirent *dirent;
113 unsigned u64s = BKEY_U64s + dirent_val_u64s(name->len);
115 if (name->len > BCH_NAME_MAX)
116 return ERR_PTR(-ENAMETOOLONG);
118 BUG_ON(u64s > U8_MAX);
120 dirent = bch2_trans_kmalloc(trans, u64s * sizeof(u64));
124 bkey_dirent_init(&dirent->k_i);
125 dirent->k.u64s = u64s;
126 dirent->v.d_inum = cpu_to_le64(dst);
127 dirent->v.d_type = type;
129 memcpy(dirent->v.d_name, name->name, name->len);
130 memset(dirent->v.d_name + name->len, 0,
131 bkey_val_bytes(&dirent->k) -
132 offsetof(struct bch_dirent, d_name) -
135 EBUG_ON(bch2_dirent_name_bytes(dirent_i_to_s_c(dirent)) != name->len);
140 int __bch2_dirent_create(struct btree_trans *trans,
141 u64 dir_inum, const struct bch_hash_info *hash_info,
142 u8 type, const struct qstr *name, u64 dst_inum,
145 struct bkey_i_dirent *dirent;
148 dirent = dirent_create_key(trans, type, name, dst_inum);
149 ret = PTR_ERR_OR_ZERO(dirent);
153 return bch2_hash_set(trans, bch2_dirent_hash_desc, hash_info,
154 dir_inum, &dirent->k_i, flags);
157 int bch2_dirent_create(struct bch_fs *c, u64 dir_inum,
158 const struct bch_hash_info *hash_info,
159 u8 type, const struct qstr *name, u64 dst_inum,
160 u64 *journal_seq, int flags)
162 return bch2_trans_do(c, journal_seq, flags,
163 __bch2_dirent_create(&trans, dir_inum, hash_info,
164 type, name, dst_inum, flags));
167 static void dirent_copy_target(struct bkey_i_dirent *dst,
168 struct bkey_s_c_dirent src)
170 dst->v.d_inum = src.v->d_inum;
171 dst->v.d_type = src.v->d_type;
174 static struct bpos bch2_dirent_pos(struct bch_inode_info *inode,
175 const struct qstr *name)
177 return POS(inode->v.i_ino, bch2_dirent_hash(&inode->ei_str_hash, name));
180 int bch2_dirent_rename(struct btree_trans *trans,
181 struct bch_inode_info *src_dir, const struct qstr *src_name,
182 struct bch_inode_info *dst_dir, const struct qstr *dst_name,
183 enum bch_rename_mode mode)
185 struct btree_iter *src_iter, *dst_iter;
186 struct bkey_s_c old_src, old_dst;
187 struct bkey_i_dirent *new_src = NULL, *new_dst = NULL;
188 struct bpos dst_pos = bch2_dirent_pos(dst_dir, dst_name);
194 * Note that in BCH_RENAME mode, we're _not_ checking if
195 * the target already exists - we're relying on the VFS
196 * to do that check for us for correctness:
198 dst_iter = mode == BCH_RENAME
199 ? bch2_hash_hole(trans, bch2_dirent_hash_desc,
200 &dst_dir->ei_str_hash,
201 dst_dir->v.i_ino, dst_name)
202 : bch2_hash_lookup(trans, bch2_dirent_hash_desc,
203 &dst_dir->ei_str_hash,
204 dst_dir->v.i_ino, dst_name,
206 if (IS_ERR(dst_iter))
207 return PTR_ERR(dst_iter);
208 old_dst = bch2_btree_iter_peek_slot(dst_iter);
211 src_iter = bch2_hash_lookup(trans, bch2_dirent_hash_desc,
212 &src_dir->ei_str_hash,
213 src_dir->v.i_ino, src_name,
215 if (IS_ERR(src_iter))
216 return PTR_ERR(src_iter);
217 old_src = bch2_btree_iter_peek_slot(src_iter);
219 /* Create new dst key: */
220 new_dst = dirent_create_key(trans, 0, dst_name, 0);
222 return PTR_ERR(new_dst);
224 dirent_copy_target(new_dst, bkey_s_c_to_dirent(old_src));
225 new_dst->k.p = dst_iter->pos;
227 /* Create new src key: */
228 if (mode == BCH_RENAME_EXCHANGE) {
229 new_src = dirent_create_key(trans, 0, src_name, 0);
231 return PTR_ERR(new_src);
233 dirent_copy_target(new_src, bkey_s_c_to_dirent(old_dst));
234 new_src->k.p = src_iter->pos;
236 new_src = bch2_trans_kmalloc(trans, sizeof(struct bkey_i));
238 return PTR_ERR(new_src);
239 bkey_init(&new_src->k);
240 new_src->k.p = src_iter->pos;
242 if (bkey_cmp(dst_pos, src_iter->pos) <= 0 &&
243 bkey_cmp(src_iter->pos, dst_iter->pos) < 0) {
245 * We have a hash collision for the new dst key,
246 * and new_src - the key we're deleting - is between
247 * new_dst's hashed slot and the slot we're going to be
248 * inserting it into - oops. This will break the hash
249 * table if we don't deal with it:
251 if (mode == BCH_RENAME) {
253 * If we're not overwriting, we can just insert
254 * new_dst at the src position:
256 new_dst->k.p = src_iter->pos;
257 bch2_trans_update(trans,
258 BTREE_INSERT_ENTRY(src_iter,
262 /* If we're overwriting, we can't insert new_dst
263 * at a different slot because it has to
264 * overwrite old_dst - just make sure to use a
265 * whiteout when deleting src:
267 new_src->k.type = KEY_TYPE_whiteout;
270 /* Check if we need a whiteout to delete src: */
271 ret = bch2_hash_needs_whiteout(trans, bch2_dirent_hash_desc,
272 &src_dir->ei_str_hash,
278 new_src->k.type = KEY_TYPE_whiteout;
282 bch2_trans_update(trans, BTREE_INSERT_ENTRY(src_iter, &new_src->k_i));
283 bch2_trans_update(trans, BTREE_INSERT_ENTRY(dst_iter, &new_dst->k_i));
287 int __bch2_dirent_delete(struct btree_trans *trans, u64 dir_inum,
288 const struct bch_hash_info *hash_info,
289 const struct qstr *name)
291 return bch2_hash_delete(trans, bch2_dirent_hash_desc, hash_info,
295 int bch2_dirent_delete(struct bch_fs *c, u64 dir_inum,
296 const struct bch_hash_info *hash_info,
297 const struct qstr *name,
300 return bch2_trans_do(c, journal_seq,
303 __bch2_dirent_delete(&trans, dir_inum, hash_info, name));
306 u64 bch2_dirent_lookup(struct bch_fs *c, u64 dir_inum,
307 const struct bch_hash_info *hash_info,
308 const struct qstr *name)
310 struct btree_trans trans;
311 struct btree_iter *iter;
315 bch2_trans_init(&trans, c);
317 iter = bch2_hash_lookup(&trans, bch2_dirent_hash_desc,
318 hash_info, dir_inum, name, 0);
320 BUG_ON(PTR_ERR(iter) == -EINTR);
324 k = bch2_btree_iter_peek_slot(iter);
325 inum = le64_to_cpu(bkey_s_c_to_dirent(k).v->d_inum);
327 bch2_trans_exit(&trans);
331 int bch2_empty_dir(struct bch_fs *c, u64 dir_inum)
333 struct btree_iter iter;
337 for_each_btree_key(&iter, c, BTREE_ID_DIRENTS, POS(dir_inum, 0), 0, k) {
338 if (k.k->p.inode > dir_inum)
341 if (k.k->type == KEY_TYPE_dirent) {
346 bch2_btree_iter_unlock(&iter);
351 int bch2_readdir(struct bch_fs *c, struct file *file,
352 struct dir_context *ctx)
354 struct bch_inode_info *inode = file_bch_inode(file);
355 struct btree_iter iter;
357 struct bkey_s_c_dirent dirent;
360 if (!dir_emit_dots(file, ctx))
363 for_each_btree_key(&iter, c, BTREE_ID_DIRENTS,
364 POS(inode->v.i_ino, ctx->pos), 0, k) {
365 if (k.k->type != KEY_TYPE_dirent)
368 dirent = bkey_s_c_to_dirent(k);
370 if (bkey_cmp(k.k->p, POS(inode->v.i_ino, ctx->pos)) < 0)
373 if (k.k->p.inode > inode->v.i_ino)
376 len = bch2_dirent_name_bytes(dirent);
379 * XXX: dir_emit() can fault and block, while we're holding
382 if (!dir_emit(ctx, dirent.v->d_name, len,
383 le64_to_cpu(dirent.v->d_inum),
387 ctx->pos = k.k->p.offset + 1;
389 bch2_btree_iter_unlock(&iter);