1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41#include <linux/fs.h>
42#include <linux/pagemap.h>
43#include <linux/mm.h>
44#include <linux/uaccess.h>
45#include <linux/buffer_head.h>
46#include <linux/pagevec.h>
47#include <linux/prefetch.h>
48
49#define DEBUG_SUBSYSTEM S_LLITE
50
51#include "../include/obd_support.h"
52#include "../include/obd_class.h"
53#include "../include/lustre_lib.h"
54#include "../include/lustre/lustre_idl.h"
55#include "../include/lustre_lite.h"
56#include "../include/lustre_dlm.h"
57#include "../include/lustre_fid.h"
58#include "../include/lustre_kernelcomm.h"
59#include "llite_internal.h"
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143static int ll_dir_filler(void *_hash, struct page *page0)
144{
145 struct inode *inode = page0->mapping->host;
146 int hash64 = ll_i2sbi(inode)->ll_flags & LL_SBI_64BIT_HASH;
147 struct obd_export *exp = ll_i2sbi(inode)->ll_md_exp;
148 struct ptlrpc_request *request;
149 struct mdt_body *body;
150 struct md_op_data *op_data;
151 __u64 hash = *((__u64 *)_hash);
152 struct page **page_pool;
153 struct page *page;
154 struct lu_dirpage *dp;
155 int max_pages = ll_i2sbi(inode)->ll_md_brw_size >> PAGE_SHIFT;
156 int nrdpgs = 0;
157 int npages;
158 int i;
159 int rc;
160
161 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) hash %llu\n",
162 inode->i_ino, inode->i_generation, inode, hash);
163
164 LASSERT(max_pages > 0 && max_pages <= MD_MAX_BRW_PAGES);
165
166 page_pool = kcalloc(max_pages, sizeof(page), GFP_NOFS);
167 if (page_pool) {
168 page_pool[0] = page0;
169 } else {
170 page_pool = &page0;
171 max_pages = 1;
172 }
173 for (npages = 1; npages < max_pages; npages++) {
174 page = page_cache_alloc_cold(inode->i_mapping);
175 if (!page)
176 break;
177 page_pool[npages] = page;
178 }
179
180 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
181 LUSTRE_OPC_ANY, NULL);
182 op_data->op_npages = npages;
183 op_data->op_offset = hash;
184 rc = md_readpage(exp, op_data, page_pool, &request);
185 ll_finish_md_op_data(op_data);
186 if (rc < 0) {
187
188 delete_from_page_cache(page0);
189 } else if (rc == 0) {
190 body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY);
191
192 if (body->valid & OBD_MD_FLSIZE)
193 cl_isize_write(inode, body->size);
194
195 nrdpgs = (request->rq_bulk->bd_nob_transferred+PAGE_SIZE-1)
196 >> PAGE_SHIFT;
197 SetPageUptodate(page0);
198 }
199 unlock_page(page0);
200 ptlrpc_req_finished(request);
201
202 CDEBUG(D_VFSTRACE, "read %d/%d pages\n", nrdpgs, npages);
203
204 for (i = 1; i < npages; i++) {
205 unsigned long offset;
206 int ret;
207
208 page = page_pool[i];
209
210 if (rc < 0 || i >= nrdpgs) {
211 put_page(page);
212 continue;
213 }
214
215 SetPageUptodate(page);
216
217 dp = kmap(page);
218 hash = le64_to_cpu(dp->ldp_hash_start);
219 kunmap(page);
220
221 offset = hash_x_index(hash, hash64);
222
223 prefetchw(&page->flags);
224 ret = add_to_page_cache_lru(page, inode->i_mapping, offset,
225 GFP_NOFS);
226 if (ret == 0) {
227 unlock_page(page);
228 } else {
229 CDEBUG(D_VFSTRACE, "page %lu add to page cache failed: %d\n",
230 offset, ret);
231 }
232 put_page(page);
233 }
234
235 if (page_pool != &page0)
236 kfree(page_pool);
237 return rc;
238}
239
240void ll_release_page(struct page *page, int remove)
241{
242 kunmap(page);
243 if (remove) {
244 lock_page(page);
245 if (likely(page->mapping))
246 truncate_complete_page(page->mapping, page);
247 unlock_page(page);
248 }
249 put_page(page);
250}
251
252
253
254
255static struct page *ll_dir_page_locate(struct inode *dir, __u64 *hash,
256 __u64 *start, __u64 *end)
257{
258 int hash64 = ll_i2sbi(dir)->ll_flags & LL_SBI_64BIT_HASH;
259 struct address_space *mapping = dir->i_mapping;
260
261
262
263
264
265 unsigned long offset = hash_x_index(*hash, hash64);
266 struct page *page;
267 int found;
268
269 spin_lock_irq(&mapping->tree_lock);
270 found = radix_tree_gang_lookup(&mapping->page_tree,
271 (void **)&page, offset, 1);
272 if (found > 0 && !radix_tree_exceptional_entry(page)) {
273 struct lu_dirpage *dp;
274
275 get_page(page);
276 spin_unlock_irq(&mapping->tree_lock);
277
278
279
280
281
282
283
284
285 wait_on_page_locked(page);
286 if (PageUptodate(page)) {
287 dp = kmap(page);
288 if (BITS_PER_LONG == 32 && hash64) {
289 *start = le64_to_cpu(dp->ldp_hash_start) >> 32;
290 *end = le64_to_cpu(dp->ldp_hash_end) >> 32;
291 *hash = *hash >> 32;
292 } else {
293 *start = le64_to_cpu(dp->ldp_hash_start);
294 *end = le64_to_cpu(dp->ldp_hash_end);
295 }
296 LASSERTF(*start <= *hash, "start = %#llx,end = %#llx,hash = %#llx\n",
297 *start, *end, *hash);
298 CDEBUG(D_VFSTRACE, "page %lu [%llu %llu], hash %llu\n",
299 offset, *start, *end, *hash);
300 if (*hash > *end) {
301 ll_release_page(page, 0);
302 page = NULL;
303 } else if (*end != *start && *hash == *end) {
304
305
306
307
308
309
310 ll_release_page(page,
311 le32_to_cpu(dp->ldp_flags) & LDF_COLLIDE);
312 page = NULL;
313 }
314 } else {
315 put_page(page);
316 page = ERR_PTR(-EIO);
317 }
318
319 } else {
320 spin_unlock_irq(&mapping->tree_lock);
321 page = NULL;
322 }
323 return page;
324}
325
326struct page *ll_get_dir_page(struct inode *dir, __u64 hash,
327 struct ll_dir_chain *chain)
328{
329 ldlm_policy_data_t policy = {.l_inodebits = {MDS_INODELOCK_UPDATE} };
330 struct address_space *mapping = dir->i_mapping;
331 struct lustre_handle lockh;
332 struct lu_dirpage *dp;
333 struct page *page;
334 enum ldlm_mode mode;
335 int rc;
336 __u64 start = 0;
337 __u64 end = 0;
338 __u64 lhash = hash;
339 struct ll_inode_info *lli = ll_i2info(dir);
340 int hash64 = ll_i2sbi(dir)->ll_flags & LL_SBI_64BIT_HASH;
341
342 mode = LCK_PR;
343 rc = md_lock_match(ll_i2sbi(dir)->ll_md_exp, LDLM_FL_BLOCK_GRANTED,
344 ll_inode2fid(dir), LDLM_IBITS, &policy, mode, &lockh);
345 if (!rc) {
346 struct ldlm_enqueue_info einfo = {
347 .ei_type = LDLM_IBITS,
348 .ei_mode = mode,
349 .ei_cb_bl = ll_md_blocking_ast,
350 .ei_cb_cp = ldlm_completion_ast,
351 };
352 struct lookup_intent it = { .it_op = IT_READDIR };
353 struct ptlrpc_request *request;
354 struct md_op_data *op_data;
355
356 op_data = ll_prep_md_op_data(NULL, dir, dir, NULL, 0, 0,
357 LUSTRE_OPC_ANY, NULL);
358 if (IS_ERR(op_data))
359 return (void *)op_data;
360
361 rc = md_enqueue(ll_i2sbi(dir)->ll_md_exp, &einfo, &it,
362 op_data, &lockh, NULL, 0, NULL, 0);
363
364 ll_finish_md_op_data(op_data);
365
366 request = (struct ptlrpc_request *)it.d.lustre.it_data;
367 if (request)
368 ptlrpc_req_finished(request);
369 if (rc < 0) {
370 CERROR("lock enqueue: " DFID " at %llu: rc %d\n",
371 PFID(ll_inode2fid(dir)), hash, rc);
372 return ERR_PTR(rc);
373 }
374
375 CDEBUG(D_INODE, "setting lr_lvb_inode to inode %p (%lu/%u)\n",
376 dir, dir->i_ino, dir->i_generation);
377 md_set_lock_data(ll_i2sbi(dir)->ll_md_exp,
378 &it.d.lustre.it_lock_handle, dir, NULL);
379 } else {
380
381
382
383 md_set_lock_data(ll_i2sbi(dir)->ll_md_exp, &lockh.cookie,
384 dir, NULL);
385 }
386 ldlm_lock_dump_handle(D_OTHER, &lockh);
387
388 mutex_lock(&lli->lli_readdir_mutex);
389 page = ll_dir_page_locate(dir, &lhash, &start, &end);
390 if (IS_ERR(page)) {
391 CERROR("dir page locate: "DFID" at %llu: rc %ld\n",
392 PFID(ll_inode2fid(dir)), lhash, PTR_ERR(page));
393 goto out_unlock;
394 } else if (page) {
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409 goto hash_collision;
410 }
411
412 page = read_cache_page(mapping, hash_x_index(hash, hash64),
413 ll_dir_filler, &lhash);
414 if (IS_ERR(page)) {
415 CERROR("read cache page: "DFID" at %llu: rc %ld\n",
416 PFID(ll_inode2fid(dir)), hash, PTR_ERR(page));
417 goto out_unlock;
418 }
419
420 wait_on_page_locked(page);
421 (void)kmap(page);
422 if (!PageUptodate(page)) {
423 CERROR("page not updated: "DFID" at %llu: rc %d\n",
424 PFID(ll_inode2fid(dir)), hash, -5);
425 goto fail;
426 }
427 if (!PageChecked(page))
428
429 SetPageChecked(page);
430 if (PageError(page)) {
431 CERROR("page error: "DFID" at %llu: rc %d\n",
432 PFID(ll_inode2fid(dir)), hash, -5);
433 goto fail;
434 }
435hash_collision:
436 dp = page_address(page);
437 if (BITS_PER_LONG == 32 && hash64) {
438 start = le64_to_cpu(dp->ldp_hash_start) >> 32;
439 end = le64_to_cpu(dp->ldp_hash_end) >> 32;
440 lhash = hash >> 32;
441 } else {
442 start = le64_to_cpu(dp->ldp_hash_start);
443 end = le64_to_cpu(dp->ldp_hash_end);
444 lhash = hash;
445 }
446 if (end == start) {
447 LASSERT(start == lhash);
448 CWARN("Page-wide hash collision: %llu\n", end);
449 if (BITS_PER_LONG == 32 && hash64)
450 CWARN("Real page-wide hash collision at [%llu %llu] with hash %llu\n",
451 le64_to_cpu(dp->ldp_hash_start),
452 le64_to_cpu(dp->ldp_hash_end), hash);
453
454
455
456
457
458 goto fail;
459 }
460out_unlock:
461 mutex_unlock(&lli->lli_readdir_mutex);
462 ldlm_lock_decref(&lockh, mode);
463 return page;
464
465fail:
466 ll_release_page(page, 1);
467 page = ERR_PTR(-EIO);
468 goto out_unlock;
469}
470
471int ll_dir_read(struct inode *inode, struct dir_context *ctx)
472{
473 struct ll_inode_info *info = ll_i2info(inode);
474 struct ll_sb_info *sbi = ll_i2sbi(inode);
475 __u64 pos = ctx->pos;
476 int api32 = ll_need_32bit_api(sbi);
477 int hash64 = sbi->ll_flags & LL_SBI_64BIT_HASH;
478 struct page *page;
479 struct ll_dir_chain chain;
480 int done = 0;
481 int rc = 0;
482
483 ll_dir_chain_init(&chain);
484
485 page = ll_get_dir_page(inode, pos, &chain);
486
487 while (rc == 0 && !done) {
488 struct lu_dirpage *dp;
489 struct lu_dirent *ent;
490
491 if (!IS_ERR(page)) {
492
493
494
495
496 __u64 hash = MDS_DIR_END_OFF;
497 __u64 next;
498
499 dp = page_address(page);
500 for (ent = lu_dirent_start(dp); ent && !done;
501 ent = lu_dirent_next(ent)) {
502 __u16 type;
503 int namelen;
504 struct lu_fid fid;
505 __u64 lhash;
506 __u64 ino;
507
508
509
510
511
512 hash = le64_to_cpu(ent->lde_hash);
513 if (hash < pos)
514
515
516
517
518 continue;
519
520 namelen = le16_to_cpu(ent->lde_namelen);
521 if (namelen == 0)
522
523
524
525 continue;
526
527 if (api32 && hash64)
528 lhash = hash >> 32;
529 else
530 lhash = hash;
531 fid_le_to_cpu(&fid, &ent->lde_fid);
532 ino = cl_fid_build_ino(&fid, api32);
533 type = ll_dirent_type_get(ent);
534 ctx->pos = lhash;
535
536
537
538
539
540 done = !dir_emit(ctx, ent->lde_name,
541 namelen, ino, type);
542 }
543 next = le64_to_cpu(dp->ldp_hash_end);
544 if (!done) {
545 pos = next;
546 if (pos == MDS_DIR_END_OFF) {
547
548
549
550 done = 1;
551 ll_release_page(page, 0);
552 } else if (1 ) {
553
554
555
556
557 ll_release_page(page,
558 le32_to_cpu(dp->ldp_flags) &
559 LDF_COLLIDE);
560 next = pos;
561 page = ll_get_dir_page(inode, pos,
562 &chain);
563 } else {
564
565
566
567 LASSERT(le32_to_cpu(dp->ldp_flags) &
568 LDF_COLLIDE);
569 ll_release_page(page, 1);
570 }
571 } else {
572 pos = hash;
573 ll_release_page(page, 0);
574 }
575 } else {
576 rc = PTR_ERR(page);
577 CERROR("error reading dir "DFID" at %lu: rc %d\n",
578 PFID(&info->lli_fid), (unsigned long)pos, rc);
579 }
580 }
581
582 ctx->pos = pos;
583 ll_dir_chain_fini(&chain);
584 return rc;
585}
586
587static int ll_readdir(struct file *filp, struct dir_context *ctx)
588{
589 struct inode *inode = file_inode(filp);
590 struct ll_file_data *lfd = LUSTRE_FPRIVATE(filp);
591 struct ll_sb_info *sbi = ll_i2sbi(inode);
592 int hash64 = sbi->ll_flags & LL_SBI_64BIT_HASH;
593 int api32 = ll_need_32bit_api(sbi);
594 int rc;
595
596 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) pos %lu/%llu 32bit_api %d\n",
597 inode->i_ino, inode->i_generation,
598 inode, (unsigned long)lfd->lfd_pos, i_size_read(inode), api32);
599
600 if (lfd->lfd_pos == MDS_DIR_END_OFF) {
601
602
603
604 rc = 0;
605 goto out;
606 }
607
608 ctx->pos = lfd->lfd_pos;
609 rc = ll_dir_read(inode, ctx);
610 lfd->lfd_pos = ctx->pos;
611 if (ctx->pos == MDS_DIR_END_OFF) {
612 if (api32)
613 ctx->pos = LL_DIR_END_OFF_32BIT;
614 else
615 ctx->pos = LL_DIR_END_OFF;
616 } else {
617 if (api32 && hash64)
618 ctx->pos >>= 32;
619 }
620 filp->f_version = inode->i_version;
621
622out:
623 if (!rc)
624 ll_stats_ops_tally(sbi, LPROC_LL_READDIR, 1);
625
626 return rc;
627}
628
629static int ll_send_mgc_param(struct obd_export *mgc, char *string)
630{
631 struct mgs_send_param *msp;
632 int rc = 0;
633
634 msp = kzalloc(sizeof(*msp), GFP_NOFS);
635 if (!msp)
636 return -ENOMEM;
637
638 strlcpy(msp->mgs_param, string, sizeof(msp->mgs_param));
639 rc = obd_set_info_async(NULL, mgc, sizeof(KEY_SET_INFO), KEY_SET_INFO,
640 sizeof(struct mgs_send_param), msp, NULL);
641 if (rc)
642 CERROR("Failed to set parameter: %d\n", rc);
643 kfree(msp);
644
645 return rc;
646}
647
648static int ll_dir_setdirstripe(struct inode *dir, struct lmv_user_md *lump,
649 char *filename)
650{
651 struct ptlrpc_request *request = NULL;
652 struct md_op_data *op_data;
653 struct ll_sb_info *sbi = ll_i2sbi(dir);
654 int mode;
655 int err;
656
657 mode = (~current_umask() & 0755) | S_IFDIR;
658 op_data = ll_prep_md_op_data(NULL, dir, NULL, filename,
659 strlen(filename), mode, LUSTRE_OPC_MKDIR,
660 lump);
661 if (IS_ERR(op_data)) {
662 err = PTR_ERR(op_data);
663 goto err_exit;
664 }
665
666 op_data->op_cli_flags |= CLI_SET_MEA;
667 err = md_create(sbi->ll_md_exp, op_data, lump, sizeof(*lump), mode,
668 from_kuid(&init_user_ns, current_fsuid()),
669 from_kgid(&init_user_ns, current_fsgid()),
670 cfs_curproc_cap_pack(), 0, &request);
671 ll_finish_md_op_data(op_data);
672 if (err)
673 goto err_exit;
674err_exit:
675 ptlrpc_req_finished(request);
676 return err;
677}
678
679int ll_dir_setstripe(struct inode *inode, struct lov_user_md *lump,
680 int set_default)
681{
682 struct ll_sb_info *sbi = ll_i2sbi(inode);
683 struct md_op_data *op_data;
684 struct ptlrpc_request *req = NULL;
685 int rc = 0;
686 struct lustre_sb_info *lsi = s2lsi(inode->i_sb);
687 struct obd_device *mgc = lsi->lsi_mgc;
688 int lum_size;
689
690 if (lump) {
691
692
693
694
695
696 switch (lump->lmm_magic) {
697 case LOV_USER_MAGIC_V1: {
698 if (lump->lmm_magic != cpu_to_le32(LOV_USER_MAGIC_V1))
699 lustre_swab_lov_user_md_v1(lump);
700 lum_size = sizeof(struct lov_user_md_v1);
701 break;
702 }
703 case LOV_USER_MAGIC_V3: {
704 if (lump->lmm_magic != cpu_to_le32(LOV_USER_MAGIC_V3))
705 lustre_swab_lov_user_md_v3(
706 (struct lov_user_md_v3 *)lump);
707 lum_size = sizeof(struct lov_user_md_v3);
708 break;
709 }
710 default: {
711 CDEBUG(D_IOCTL, "bad userland LOV MAGIC: %#08x != %#08x nor %#08x\n",
712 lump->lmm_magic, LOV_USER_MAGIC_V1,
713 LOV_USER_MAGIC_V3);
714 return -EINVAL;
715 }
716 }
717 } else {
718 lum_size = sizeof(struct lov_user_md_v1);
719 }
720
721 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
722 LUSTRE_OPC_ANY, NULL);
723 if (IS_ERR(op_data))
724 return PTR_ERR(op_data);
725
726 if (lump && lump->lmm_magic == cpu_to_le32(LMV_USER_MAGIC))
727 op_data->op_cli_flags |= CLI_SET_MEA;
728
729
730 rc = md_setattr(sbi->ll_md_exp, op_data, lump, lum_size,
731 NULL, 0, &req, NULL);
732 ll_finish_md_op_data(op_data);
733 ptlrpc_req_finished(req);
734 if (rc) {
735 if (rc != -EPERM && rc != -EACCES)
736 CERROR("mdc_setattr fails: rc = %d\n", rc);
737 }
738
739
740
741
742
743 if (set_default && mgc->u.cli.cl_mgc_mgsexp) {
744 char *param = NULL;
745 char *buf;
746
747 param = kzalloc(MGS_PARAM_MAXLEN, GFP_NOFS);
748 if (!param)
749 return -ENOMEM;
750
751 buf = param;
752
753 ll_get_fsname(inode->i_sb, buf, MTI_NAME_MAXLEN);
754 strcat(buf, "-MDT0000.lov");
755 buf += strlen(buf);
756
757
758 sprintf(buf, ".stripesize=%u",
759 lump ? le32_to_cpu(lump->lmm_stripe_size) : 0);
760 rc = ll_send_mgc_param(mgc->u.cli.cl_mgc_mgsexp, param);
761 if (rc)
762 goto end;
763
764
765 sprintf(buf, ".stripecount=%hd",
766 lump ? le16_to_cpu(lump->lmm_stripe_count) : 0);
767 rc = ll_send_mgc_param(mgc->u.cli.cl_mgc_mgsexp, param);
768 if (rc)
769 goto end;
770
771
772 sprintf(buf, ".stripeoffset=%hd",
773 lump ? le16_to_cpu(lump->lmm_stripe_offset) :
774 (typeof(lump->lmm_stripe_offset))(-1));
775 rc = ll_send_mgc_param(mgc->u.cli.cl_mgc_mgsexp, param);
776
777end:
778 kfree(param);
779 }
780 return rc;
781}
782
783int ll_dir_getstripe(struct inode *inode, struct lov_mds_md **lmmp,
784 int *lmm_size, struct ptlrpc_request **request)
785{
786 struct ll_sb_info *sbi = ll_i2sbi(inode);
787 struct mdt_body *body;
788 struct lov_mds_md *lmm = NULL;
789 struct ptlrpc_request *req = NULL;
790 int rc, lmmsize;
791 struct md_op_data *op_data;
792
793 rc = ll_get_default_mdsize(sbi, &lmmsize);
794 if (rc)
795 return rc;
796
797 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
798 0, lmmsize, LUSTRE_OPC_ANY,
799 NULL);
800 if (IS_ERR(op_data))
801 return PTR_ERR(op_data);
802
803 op_data->op_valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA;
804 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
805 ll_finish_md_op_data(op_data);
806 if (rc < 0) {
807 CDEBUG(D_INFO, "md_getattr failed on inode %lu/%u: rc %d\n",
808 inode->i_ino,
809 inode->i_generation, rc);
810 goto out;
811 }
812
813 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
814
815 lmmsize = body->eadatasize;
816
817 if (!(body->valid & (OBD_MD_FLEASIZE | OBD_MD_FLDIREA)) ||
818 lmmsize == 0) {
819 rc = -ENODATA;
820 goto out;
821 }
822
823 lmm = req_capsule_server_sized_get(&req->rq_pill,
824 &RMF_MDT_MD, lmmsize);
825
826
827
828
829
830
831
832 switch (le32_to_cpu(lmm->lmm_magic)) {
833 case LOV_MAGIC_V1:
834 if (cpu_to_le32(LOV_MAGIC) != LOV_MAGIC)
835 lustre_swab_lov_user_md_v1((struct lov_user_md_v1 *)lmm);
836 break;
837 case LOV_MAGIC_V3:
838 if (cpu_to_le32(LOV_MAGIC) != LOV_MAGIC)
839 lustre_swab_lov_user_md_v3((struct lov_user_md_v3 *)lmm);
840 break;
841 default:
842 CERROR("unknown magic: %lX\n", (unsigned long)lmm->lmm_magic);
843 rc = -EPROTO;
844 }
845out:
846 *lmmp = lmm;
847 *lmm_size = lmmsize;
848 *request = req;
849 return rc;
850}
851
852
853
854
855int ll_get_mdt_idx(struct inode *inode)
856{
857 struct ll_sb_info *sbi = ll_i2sbi(inode);
858 struct md_op_data *op_data;
859 int rc, mdtidx;
860
861 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0,
862 0, LUSTRE_OPC_ANY, NULL);
863 if (IS_ERR(op_data))
864 return PTR_ERR(op_data);
865
866 op_data->op_flags |= MF_GET_MDT_IDX;
867 rc = md_getattr(sbi->ll_md_exp, op_data, NULL);
868 mdtidx = op_data->op_mds;
869 ll_finish_md_op_data(op_data);
870 if (rc < 0) {
871 CDEBUG(D_INFO, "md_getattr_name: %d\n", rc);
872 return rc;
873 }
874 return mdtidx;
875}
876
877
878
879
880
881
882
883
884
885
886
887
888static int ll_ioc_copy_start(struct super_block *sb, struct hsm_copy *copy)
889{
890 struct ll_sb_info *sbi = ll_s2sbi(sb);
891 struct hsm_progress_kernel hpk;
892 int rc;
893
894
895 hpk.hpk_fid = copy->hc_hai.hai_fid;
896 hpk.hpk_cookie = copy->hc_hai.hai_cookie;
897 hpk.hpk_extent.offset = copy->hc_hai.hai_extent.offset;
898 hpk.hpk_extent.length = 0;
899 hpk.hpk_flags = 0;
900 hpk.hpk_errval = 0;
901 hpk.hpk_data_version = 0;
902
903
904 if (copy->hc_hai.hai_action == HSMA_ARCHIVE) {
905 struct inode *inode;
906 __u64 data_version = 0;
907
908
909 inode = search_inode_for_lustre(sb, ©->hc_hai.hai_fid);
910 if (IS_ERR(inode)) {
911 hpk.hpk_flags |= HP_FLAG_RETRY;
912
913 hpk.hpk_errval = -PTR_ERR(inode);
914 rc = PTR_ERR(inode);
915 goto progress;
916 }
917
918
919 rc = ll_data_version(inode, &data_version, 1);
920 iput(inode);
921 if (rc != 0) {
922 CDEBUG(D_HSM, "Could not read file data version of "
923 DFID" (rc = %d). Archive request (%#llx) could not be done.\n",
924 PFID(©->hc_hai.hai_fid), rc,
925 copy->hc_hai.hai_cookie);
926 hpk.hpk_flags |= HP_FLAG_RETRY;
927
928 hpk.hpk_errval = -rc;
929 goto progress;
930 }
931
932
933
934
935 copy->hc_data_version = data_version;
936 }
937
938progress:
939 rc = obd_iocontrol(LL_IOC_HSM_PROGRESS, sbi->ll_md_exp, sizeof(hpk),
940 &hpk, NULL);
941
942 return rc;
943}
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960static int ll_ioc_copy_end(struct super_block *sb, struct hsm_copy *copy)
961{
962 struct ll_sb_info *sbi = ll_s2sbi(sb);
963 struct hsm_progress_kernel hpk;
964 int rc;
965
966
967
968
969
970
971
972 hpk.hpk_fid = copy->hc_hai.hai_fid;
973 hpk.hpk_cookie = copy->hc_hai.hai_cookie;
974 hpk.hpk_extent = copy->hc_hai.hai_extent;
975 hpk.hpk_flags = copy->hc_flags | HP_FLAG_COMPLETED;
976 hpk.hpk_errval = copy->hc_errval;
977 hpk.hpk_data_version = 0;
978
979
980
981
982
983
984 if (((copy->hc_hai.hai_action == HSMA_ARCHIVE) ||
985 (copy->hc_hai.hai_action == HSMA_RESTORE)) &&
986 (copy->hc_errval == 0)) {
987 struct inode *inode;
988 __u64 data_version = 0;
989
990
991 inode = search_inode_for_lustre(sb, ©->hc_hai.hai_fid);
992 if (IS_ERR(inode)) {
993 hpk.hpk_flags |= HP_FLAG_RETRY;
994
995 hpk.hpk_errval = -PTR_ERR(inode);
996 rc = PTR_ERR(inode);
997 goto progress;
998 }
999
1000 rc = ll_data_version(inode, &data_version,
1001 copy->hc_hai.hai_action == HSMA_ARCHIVE);
1002 iput(inode);
1003 if (rc) {
1004 CDEBUG(D_HSM, "Could not read file data version. Request could not be confirmed.\n");
1005 if (hpk.hpk_errval == 0)
1006 hpk.hpk_errval = -rc;
1007 goto progress;
1008 }
1009
1010
1011
1012
1013 hpk.hpk_data_version = data_version;
1014
1015
1016
1017
1018 if ((copy->hc_hai.hai_action == HSMA_ARCHIVE) &&
1019 (copy->hc_data_version != data_version)) {
1020 CDEBUG(D_HSM, "File data version mismatched. File content was changed during archiving. "
1021 DFID", start:%#llx current:%#llx\n",
1022 PFID(©->hc_hai.hai_fid),
1023 copy->hc_data_version, data_version);
1024
1025
1026
1027
1028
1029
1030
1031
1032 hpk.hpk_flags &= ~HP_FLAG_RETRY;
1033
1034 hpk.hpk_errval = EBUSY;
1035 }
1036
1037 }
1038
1039progress:
1040 rc = obd_iocontrol(LL_IOC_HSM_PROGRESS, sbi->ll_md_exp, sizeof(hpk),
1041 &hpk, NULL);
1042
1043 return rc;
1044}
1045
1046static int copy_and_ioctl(int cmd, struct obd_export *exp,
1047 const void __user *data, size_t size)
1048{
1049 void *copy;
1050 int rc;
1051
1052 copy = kzalloc(size, GFP_NOFS);
1053 if (!copy)
1054 return -ENOMEM;
1055
1056 if (copy_from_user(copy, data, size)) {
1057 rc = -EFAULT;
1058 goto out;
1059 }
1060
1061 rc = obd_iocontrol(cmd, exp, size, copy, NULL);
1062out:
1063 kfree(copy);
1064
1065 return rc;
1066}
1067
1068static int quotactl_ioctl(struct ll_sb_info *sbi, struct if_quotactl *qctl)
1069{
1070 int cmd = qctl->qc_cmd;
1071 int type = qctl->qc_type;
1072 int id = qctl->qc_id;
1073 int valid = qctl->qc_valid;
1074 int rc = 0;
1075
1076 switch (cmd) {
1077 case LUSTRE_Q_INVALIDATE:
1078 case LUSTRE_Q_FINVALIDATE:
1079 case Q_QUOTAON:
1080 case Q_QUOTAOFF:
1081 case Q_SETQUOTA:
1082 case Q_SETINFO:
1083 if (!capable(CFS_CAP_SYS_ADMIN) ||
1084 sbi->ll_flags & LL_SBI_RMT_CLIENT)
1085 return -EPERM;
1086 break;
1087 case Q_GETQUOTA:
1088 if (((type == USRQUOTA &&
1089 !uid_eq(current_euid(), make_kuid(&init_user_ns, id))) ||
1090 (type == GRPQUOTA &&
1091 !in_egroup_p(make_kgid(&init_user_ns, id)))) &&
1092 (!capable(CFS_CAP_SYS_ADMIN) ||
1093 sbi->ll_flags & LL_SBI_RMT_CLIENT))
1094 return -EPERM;
1095 break;
1096 case Q_GETINFO:
1097 break;
1098 default:
1099 CERROR("unsupported quotactl op: %#x\n", cmd);
1100 return -ENOTTY;
1101 }
1102
1103 if (valid != QC_GENERAL) {
1104 if (sbi->ll_flags & LL_SBI_RMT_CLIENT)
1105 return -EOPNOTSUPP;
1106
1107 if (cmd == Q_GETINFO)
1108 qctl->qc_cmd = Q_GETOINFO;
1109 else if (cmd == Q_GETQUOTA)
1110 qctl->qc_cmd = Q_GETOQUOTA;
1111 else
1112 return -EINVAL;
1113
1114 switch (valid) {
1115 case QC_MDTIDX:
1116 rc = obd_iocontrol(OBD_IOC_QUOTACTL, sbi->ll_md_exp,
1117 sizeof(*qctl), qctl, NULL);
1118 break;
1119 case QC_OSTIDX:
1120 rc = obd_iocontrol(OBD_IOC_QUOTACTL, sbi->ll_dt_exp,
1121 sizeof(*qctl), qctl, NULL);
1122 break;
1123 case QC_UUID:
1124 rc = obd_iocontrol(OBD_IOC_QUOTACTL, sbi->ll_md_exp,
1125 sizeof(*qctl), qctl, NULL);
1126 if (rc == -EAGAIN)
1127 rc = obd_iocontrol(OBD_IOC_QUOTACTL,
1128 sbi->ll_dt_exp,
1129 sizeof(*qctl), qctl, NULL);
1130 break;
1131 default:
1132 rc = -EINVAL;
1133 break;
1134 }
1135
1136 if (rc)
1137 return rc;
1138
1139 qctl->qc_cmd = cmd;
1140 } else {
1141 struct obd_quotactl *oqctl;
1142
1143 oqctl = kzalloc(sizeof(*oqctl), GFP_NOFS);
1144 if (!oqctl)
1145 return -ENOMEM;
1146
1147 QCTL_COPY(oqctl, qctl);
1148 rc = obd_quotactl(sbi->ll_md_exp, oqctl);
1149 if (rc) {
1150 if (rc != -EALREADY && cmd == Q_QUOTAON) {
1151 oqctl->qc_cmd = Q_QUOTAOFF;
1152 obd_quotactl(sbi->ll_md_exp, oqctl);
1153 }
1154 kfree(oqctl);
1155 return rc;
1156 }
1157
1158
1159
1160 if (cmd == Q_GETQUOTA &&
1161 !(oqctl->qc_dqblk.dqb_valid & QIF_SPACE) &&
1162 !oqctl->qc_dqblk.dqb_curspace) {
1163 struct obd_quotactl *oqctl_tmp;
1164
1165 oqctl_tmp = kzalloc(sizeof(*oqctl_tmp), GFP_NOFS);
1166 if (!oqctl_tmp) {
1167 rc = -ENOMEM;
1168 goto out;
1169 }
1170
1171 oqctl_tmp->qc_cmd = Q_GETOQUOTA;
1172 oqctl_tmp->qc_id = oqctl->qc_id;
1173 oqctl_tmp->qc_type = oqctl->qc_type;
1174
1175
1176 oqctl_tmp->qc_dqblk.dqb_curspace = 0;
1177 rc = obd_quotactl(sbi->ll_dt_exp, oqctl_tmp);
1178 if (!rc || rc == -EREMOTEIO) {
1179 oqctl->qc_dqblk.dqb_curspace =
1180 oqctl_tmp->qc_dqblk.dqb_curspace;
1181 oqctl->qc_dqblk.dqb_valid |= QIF_SPACE;
1182 }
1183
1184
1185 oqctl_tmp->qc_dqblk.dqb_curspace = 0;
1186 oqctl_tmp->qc_dqblk.dqb_curinodes = 0;
1187 rc = obd_quotactl(sbi->ll_md_exp, oqctl_tmp);
1188 if (!rc || rc == -EREMOTEIO) {
1189 oqctl->qc_dqblk.dqb_curspace +=
1190 oqctl_tmp->qc_dqblk.dqb_curspace;
1191 oqctl->qc_dqblk.dqb_curinodes =
1192 oqctl_tmp->qc_dqblk.dqb_curinodes;
1193 oqctl->qc_dqblk.dqb_valid |= QIF_INODES;
1194 } else {
1195 oqctl->qc_dqblk.dqb_valid &= ~QIF_SPACE;
1196 }
1197
1198 kfree(oqctl_tmp);
1199 }
1200out:
1201 QCTL_COPY(qctl, oqctl);
1202 kfree(oqctl);
1203 }
1204
1205 return rc;
1206}
1207
1208
1209
1210
1211
1212static char *ll_getname(const char __user *filename)
1213{
1214 int ret = 0, len;
1215 char *tmp;
1216
1217 tmp = kzalloc(NAME_MAX + 1, GFP_KERNEL);
1218 if (!tmp)
1219 return ERR_PTR(-ENOMEM);
1220
1221 len = strncpy_from_user(tmp, filename, NAME_MAX + 1);
1222 if (len < 0)
1223 ret = len;
1224 else if (len == 0)
1225 ret = -ENOENT;
1226 else if (len > NAME_MAX && tmp[NAME_MAX] != 0)
1227 ret = -ENAMETOOLONG;
1228
1229 if (ret) {
1230 kfree(tmp);
1231 tmp = ERR_PTR(ret);
1232 }
1233 return tmp;
1234}
1235
1236#define ll_putname(filename) kfree(filename)
1237
1238static long ll_dir_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1239{
1240 struct inode *inode = file_inode(file);
1241 struct ll_sb_info *sbi = ll_i2sbi(inode);
1242 struct obd_ioctl_data *data;
1243 int rc = 0;
1244
1245 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), cmd=%#x\n",
1246 inode->i_ino, inode->i_generation, inode, cmd);
1247
1248
1249 if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't')
1250 return -ENOTTY;
1251
1252 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
1253 switch (cmd) {
1254 case FSFILT_IOC_GETFLAGS:
1255 case FSFILT_IOC_SETFLAGS:
1256 return ll_iocontrol(inode, file, cmd, arg);
1257 case FSFILT_IOC_GETVERSION_OLD:
1258 case FSFILT_IOC_GETVERSION:
1259 return put_user(inode->i_generation, (int __user *)arg);
1260
1261
1262
1263
1264
1265
1266 case LL_IOC_GET_MDTIDX: {
1267 int mdtidx;
1268
1269 mdtidx = ll_get_mdt_idx(inode);
1270 if (mdtidx < 0)
1271 return mdtidx;
1272
1273 if (put_user((int)mdtidx, (int __user *)arg))
1274 return -EFAULT;
1275
1276 return 0;
1277 }
1278 case IOC_MDC_LOOKUP: {
1279 struct ptlrpc_request *request = NULL;
1280 int namelen, len = 0;
1281 char *buf = NULL;
1282 char *filename;
1283 struct md_op_data *op_data;
1284
1285 rc = obd_ioctl_getdata(&buf, &len, (void __user *)arg);
1286 if (rc)
1287 return rc;
1288 data = (void *)buf;
1289
1290 filename = data->ioc_inlbuf1;
1291 namelen = strlen(filename);
1292
1293 if (namelen < 1) {
1294 CDEBUG(D_INFO, "IOC_MDC_LOOKUP missing filename\n");
1295 rc = -EINVAL;
1296 goto out_free;
1297 }
1298
1299 op_data = ll_prep_md_op_data(NULL, inode, NULL, filename, namelen,
1300 0, LUSTRE_OPC_ANY, NULL);
1301 if (IS_ERR(op_data)) {
1302 rc = PTR_ERR(op_data);
1303 goto out_free;
1304 }
1305
1306 op_data->op_valid = OBD_MD_FLID;
1307 rc = md_getattr_name(sbi->ll_md_exp, op_data, &request);
1308 ll_finish_md_op_data(op_data);
1309 if (rc < 0) {
1310 CDEBUG(D_INFO, "md_getattr_name: %d\n", rc);
1311 goto out_free;
1312 }
1313 ptlrpc_req_finished(request);
1314out_free:
1315 obd_ioctl_freedata(buf, len);
1316 return rc;
1317 }
1318 case LL_IOC_LMV_SETSTRIPE: {
1319 struct lmv_user_md *lum;
1320 char *buf = NULL;
1321 char *filename;
1322 int namelen = 0;
1323 int lumlen = 0;
1324 int len;
1325 int rc;
1326
1327 rc = obd_ioctl_getdata(&buf, &len, (void __user *)arg);
1328 if (rc)
1329 return rc;
1330
1331 data = (void *)buf;
1332 if (!data->ioc_inlbuf1 || !data->ioc_inlbuf2 ||
1333 data->ioc_inllen1 == 0 || data->ioc_inllen2 == 0) {
1334 rc = -EINVAL;
1335 goto lmv_out_free;
1336 }
1337
1338 filename = data->ioc_inlbuf1;
1339 namelen = data->ioc_inllen1;
1340
1341 if (namelen < 1) {
1342 CDEBUG(D_INFO, "IOC_MDC_LOOKUP missing filename\n");
1343 rc = -EINVAL;
1344 goto lmv_out_free;
1345 }
1346 lum = (struct lmv_user_md *)data->ioc_inlbuf2;
1347 lumlen = data->ioc_inllen2;
1348
1349 if (lum->lum_magic != LMV_USER_MAGIC ||
1350 lumlen != sizeof(*lum)) {
1351 CERROR("%s: wrong lum magic %x or size %d: rc = %d\n",
1352 filename, lum->lum_magic, lumlen, -EFAULT);
1353 rc = -EINVAL;
1354 goto lmv_out_free;
1355 }
1356
1357
1358
1359
1360
1361 rc = ll_dir_setdirstripe(inode, lum, filename);
1362lmv_out_free:
1363 obd_ioctl_freedata(buf, len);
1364 return rc;
1365
1366 }
1367 case LL_IOC_LOV_SETSTRIPE: {
1368 struct lov_user_md_v3 lumv3;
1369 struct lov_user_md_v1 *lumv1 = (struct lov_user_md_v1 *)&lumv3;
1370 struct lov_user_md_v1 __user *lumv1p = (void __user *)arg;
1371 struct lov_user_md_v3 __user *lumv3p = (void __user *)arg;
1372
1373 int set_default = 0;
1374
1375 LASSERT(sizeof(lumv3) == sizeof(*lumv3p));
1376 LASSERT(sizeof(lumv3.lmm_objects[0]) ==
1377 sizeof(lumv3p->lmm_objects[0]));
1378
1379 if (copy_from_user(lumv1, lumv1p, sizeof(*lumv1)))
1380 return -EFAULT;
1381
1382 if (lumv1->lmm_magic == LOV_USER_MAGIC_V3) {
1383 if (copy_from_user(&lumv3, lumv3p, sizeof(lumv3)))
1384 return -EFAULT;
1385 }
1386
1387 if (is_root_inode(inode))
1388 set_default = 1;
1389
1390
1391 rc = ll_dir_setstripe(inode, lumv1, set_default);
1392
1393 return rc;
1394 }
1395 case LL_IOC_LMV_GETSTRIPE: {
1396 struct lmv_user_md __user *lump = (void __user *)arg;
1397 struct lmv_user_md lum;
1398 struct lmv_user_md *tmp;
1399 int lum_size;
1400 int rc = 0;
1401 int mdtindex;
1402
1403 if (copy_from_user(&lum, lump, sizeof(struct lmv_user_md)))
1404 return -EFAULT;
1405
1406 if (lum.lum_magic != LMV_MAGIC_V1)
1407 return -EINVAL;
1408
1409 lum_size = lmv_user_md_size(1, LMV_MAGIC_V1);
1410 tmp = kzalloc(lum_size, GFP_NOFS);
1411 if (!tmp) {
1412 rc = -ENOMEM;
1413 goto free_lmv;
1414 }
1415
1416 *tmp = lum;
1417 tmp->lum_type = LMV_STRIPE_TYPE;
1418 tmp->lum_stripe_count = 1;
1419 mdtindex = ll_get_mdt_idx(inode);
1420 if (mdtindex < 0) {
1421 rc = -ENOMEM;
1422 goto free_lmv;
1423 }
1424
1425 tmp->lum_stripe_offset = mdtindex;
1426 tmp->lum_objects[0].lum_mds = mdtindex;
1427 memcpy(&tmp->lum_objects[0].lum_fid, ll_inode2fid(inode),
1428 sizeof(struct lu_fid));
1429 if (copy_to_user((void __user *)arg, tmp, lum_size)) {
1430 rc = -EFAULT;
1431 goto free_lmv;
1432 }
1433free_lmv:
1434 kfree(tmp);
1435 return rc;
1436 }
1437 case LL_IOC_LOV_SWAP_LAYOUTS:
1438 return -EPERM;
1439 case LL_IOC_OBD_STATFS:
1440 return ll_obd_statfs(inode, (void __user *)arg);
1441 case LL_IOC_LOV_GETSTRIPE:
1442 case LL_IOC_MDC_GETINFO:
1443 case IOC_MDC_GETFILEINFO:
1444 case IOC_MDC_GETFILESTRIPE: {
1445 struct ptlrpc_request *request = NULL;
1446 struct lov_user_md __user *lump;
1447 struct lov_mds_md *lmm = NULL;
1448 struct mdt_body *body;
1449 char *filename = NULL;
1450 int lmmsize;
1451
1452 if (cmd == IOC_MDC_GETFILEINFO ||
1453 cmd == IOC_MDC_GETFILESTRIPE) {
1454 filename = ll_getname((const char __user *)arg);
1455 if (IS_ERR(filename))
1456 return PTR_ERR(filename);
1457
1458 rc = ll_lov_getstripe_ea_info(inode, filename, &lmm,
1459 &lmmsize, &request);
1460 } else {
1461 rc = ll_dir_getstripe(inode, &lmm, &lmmsize, &request);
1462 }
1463
1464 if (request) {
1465 body = req_capsule_server_get(&request->rq_pill,
1466 &RMF_MDT_BODY);
1467 LASSERT(body);
1468 } else {
1469 goto out_req;
1470 }
1471
1472 if (rc < 0) {
1473 if (rc == -ENODATA && (cmd == IOC_MDC_GETFILEINFO ||
1474 cmd == LL_IOC_MDC_GETINFO)) {
1475 rc = 0;
1476 goto skip_lmm;
1477 } else
1478 goto out_req;
1479 }
1480
1481 if (cmd == IOC_MDC_GETFILESTRIPE ||
1482 cmd == LL_IOC_LOV_GETSTRIPE) {
1483 lump = (struct lov_user_md __user *)arg;
1484 } else {
1485 struct lov_user_mds_data __user *lmdp;
1486
1487 lmdp = (struct lov_user_mds_data __user *)arg;
1488 lump = &lmdp->lmd_lmm;
1489 }
1490 if (copy_to_user(lump, lmm, lmmsize)) {
1491 if (copy_to_user(lump, lmm, sizeof(*lump))) {
1492 rc = -EFAULT;
1493 goto out_req;
1494 }
1495 rc = -EOVERFLOW;
1496 }
1497skip_lmm:
1498 if (cmd == IOC_MDC_GETFILEINFO || cmd == LL_IOC_MDC_GETINFO) {
1499 struct lov_user_mds_data __user *lmdp;
1500 lstat_t st = { 0 };
1501
1502 st.st_dev = inode->i_sb->s_dev;
1503 st.st_mode = body->mode;
1504 st.st_nlink = body->nlink;
1505 st.st_uid = body->uid;
1506 st.st_gid = body->gid;
1507 st.st_rdev = body->rdev;
1508 st.st_size = body->size;
1509 st.st_blksize = PAGE_SIZE;
1510 st.st_blocks = body->blocks;
1511 st.st_atime = body->atime;
1512 st.st_mtime = body->mtime;
1513 st.st_ctime = body->ctime;
1514 st.st_ino = inode->i_ino;
1515
1516 lmdp = (struct lov_user_mds_data __user *)arg;
1517 if (copy_to_user(&lmdp->lmd_st, &st, sizeof(st))) {
1518 rc = -EFAULT;
1519 goto out_req;
1520 }
1521 }
1522
1523out_req:
1524 ptlrpc_req_finished(request);
1525 if (filename)
1526 ll_putname(filename);
1527 return rc;
1528 }
1529 case IOC_LOV_GETINFO: {
1530 struct lov_user_mds_data __user *lumd;
1531 struct lov_stripe_md *lsm;
1532 struct lov_user_md __user *lum;
1533 struct lov_mds_md *lmm;
1534 int lmmsize;
1535 lstat_t st;
1536
1537 lumd = (struct lov_user_mds_data __user *)arg;
1538 lum = &lumd->lmd_lmm;
1539
1540 rc = ll_get_max_mdsize(sbi, &lmmsize);
1541 if (rc)
1542 return rc;
1543
1544 lmm = libcfs_kvzalloc(lmmsize, GFP_NOFS);
1545 if (!lmm)
1546 return -ENOMEM;
1547 if (copy_from_user(lmm, lum, lmmsize)) {
1548 rc = -EFAULT;
1549 goto free_lmm;
1550 }
1551
1552 switch (lmm->lmm_magic) {
1553 case LOV_USER_MAGIC_V1:
1554 if (cpu_to_le32(LOV_USER_MAGIC_V1) == LOV_USER_MAGIC_V1)
1555 break;
1556
1557 lustre_swab_lov_user_md_objects(
1558 ((struct lov_user_md_v1 *)lmm)->lmm_objects,
1559 ((struct lov_user_md_v1 *)lmm)->lmm_stripe_count);
1560 lustre_swab_lov_user_md_v1((struct lov_user_md_v1 *)lmm);
1561 break;
1562 case LOV_USER_MAGIC_V3:
1563 if (cpu_to_le32(LOV_USER_MAGIC_V3) == LOV_USER_MAGIC_V3)
1564 break;
1565
1566 lustre_swab_lov_user_md_objects(
1567 ((struct lov_user_md_v3 *)lmm)->lmm_objects,
1568 ((struct lov_user_md_v3 *)lmm)->lmm_stripe_count);
1569 lustre_swab_lov_user_md_v3((struct lov_user_md_v3 *)lmm);
1570 break;
1571 default:
1572 rc = -EINVAL;
1573 goto free_lmm;
1574 }
1575
1576 rc = obd_unpackmd(sbi->ll_dt_exp, &lsm, lmm, lmmsize);
1577 if (rc < 0) {
1578 rc = -ENOMEM;
1579 goto free_lmm;
1580 }
1581
1582
1583 memset(&st, 0, sizeof(st));
1584
1585 rc = ll_glimpse_ioctl(sbi, lsm, &st);
1586 if (rc)
1587 goto free_lsm;
1588
1589 if (copy_to_user(&lumd->lmd_st, &st, sizeof(st))) {
1590 rc = -EFAULT;
1591 goto free_lsm;
1592 }
1593
1594free_lsm:
1595 obd_free_memmd(sbi->ll_dt_exp, &lsm);
1596free_lmm:
1597 kvfree(lmm);
1598 return rc;
1599 }
1600 case OBD_IOC_LLOG_CATINFO: {
1601 return -EOPNOTSUPP;
1602 }
1603 case OBD_IOC_QUOTACHECK: {
1604 struct obd_quotactl *oqctl;
1605 int error = 0;
1606
1607 if (!capable(CFS_CAP_SYS_ADMIN) ||
1608 sbi->ll_flags & LL_SBI_RMT_CLIENT)
1609 return -EPERM;
1610
1611 oqctl = kzalloc(sizeof(*oqctl), GFP_NOFS);
1612 if (!oqctl)
1613 return -ENOMEM;
1614 oqctl->qc_type = arg;
1615 rc = obd_quotacheck(sbi->ll_md_exp, oqctl);
1616 if (rc < 0) {
1617 CDEBUG(D_INFO, "md_quotacheck failed: rc %d\n", rc);
1618 error = rc;
1619 }
1620
1621 rc = obd_quotacheck(sbi->ll_dt_exp, oqctl);
1622 if (rc < 0)
1623 CDEBUG(D_INFO, "obd_quotacheck failed: rc %d\n", rc);
1624
1625 kfree(oqctl);
1626 return error ?: rc;
1627 }
1628 case OBD_IOC_POLL_QUOTACHECK: {
1629 struct if_quotacheck *check;
1630
1631 if (!capable(CFS_CAP_SYS_ADMIN) ||
1632 sbi->ll_flags & LL_SBI_RMT_CLIENT)
1633 return -EPERM;
1634
1635 check = kzalloc(sizeof(*check), GFP_NOFS);
1636 if (!check)
1637 return -ENOMEM;
1638
1639 rc = obd_iocontrol(cmd, sbi->ll_md_exp, 0, (void *)check,
1640 NULL);
1641 if (rc) {
1642 CDEBUG(D_QUOTA, "mdc ioctl %d failed: %d\n", cmd, rc);
1643 if (copy_to_user((void __user *)arg, check,
1644 sizeof(*check)))
1645 CDEBUG(D_QUOTA, "copy_to_user failed\n");
1646 goto out_poll;
1647 }
1648
1649 rc = obd_iocontrol(cmd, sbi->ll_dt_exp, 0, (void *)check,
1650 NULL);
1651 if (rc) {
1652 CDEBUG(D_QUOTA, "osc ioctl %d failed: %d\n", cmd, rc);
1653 if (copy_to_user((void __user *)arg, check,
1654 sizeof(*check)))
1655 CDEBUG(D_QUOTA, "copy_to_user failed\n");
1656 goto out_poll;
1657 }
1658out_poll:
1659 kfree(check);
1660 return rc;
1661 }
1662 case LL_IOC_QUOTACTL: {
1663 struct if_quotactl *qctl;
1664
1665 qctl = kzalloc(sizeof(*qctl), GFP_NOFS);
1666 if (!qctl)
1667 return -ENOMEM;
1668
1669 if (copy_from_user(qctl, (void __user *)arg, sizeof(*qctl))) {
1670 rc = -EFAULT;
1671 goto out_quotactl;
1672 }
1673
1674 rc = quotactl_ioctl(sbi, qctl);
1675
1676 if (rc == 0 && copy_to_user((void __user *)arg, qctl,
1677 sizeof(*qctl)))
1678 rc = -EFAULT;
1679
1680out_quotactl:
1681 kfree(qctl);
1682 return rc;
1683 }
1684 case OBD_IOC_GETDTNAME:
1685 case OBD_IOC_GETMDNAME:
1686 return ll_get_obd_name(inode, cmd, arg);
1687 case LL_IOC_FLUSHCTX:
1688 return ll_flush_ctx(inode);
1689#ifdef CONFIG_FS_POSIX_ACL
1690 case LL_IOC_RMTACL: {
1691 if (sbi->ll_flags & LL_SBI_RMT_CLIENT && is_root_inode(inode)) {
1692 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
1693
1694 rc = rct_add(&sbi->ll_rct, current_pid(), arg);
1695 if (!rc)
1696 fd->fd_flags |= LL_FILE_RMTACL;
1697 return rc;
1698 } else
1699 return 0;
1700 }
1701#endif
1702 case LL_IOC_GETOBDCOUNT: {
1703 int count, vallen;
1704 struct obd_export *exp;
1705
1706 if (copy_from_user(&count, (int __user *)arg, sizeof(int)))
1707 return -EFAULT;
1708
1709
1710 exp = count ? sbi->ll_md_exp : sbi->ll_dt_exp;
1711 vallen = sizeof(count);
1712 rc = obd_get_info(NULL, exp, sizeof(KEY_TGT_COUNT),
1713 KEY_TGT_COUNT, &vallen, &count, NULL);
1714 if (rc) {
1715 CERROR("get target count failed: %d\n", rc);
1716 return rc;
1717 }
1718
1719 if (copy_to_user((int __user *)arg, &count, sizeof(int)))
1720 return -EFAULT;
1721
1722 return 0;
1723 }
1724 case LL_IOC_PATH2FID:
1725 if (copy_to_user((void __user *)arg, ll_inode2fid(inode),
1726 sizeof(struct lu_fid)))
1727 return -EFAULT;
1728 return 0;
1729 case LL_IOC_GET_CONNECT_FLAGS: {
1730 return obd_iocontrol(cmd, sbi->ll_md_exp, 0, NULL,
1731 (void __user *)arg);
1732 }
1733 case OBD_IOC_CHANGELOG_SEND:
1734 case OBD_IOC_CHANGELOG_CLEAR:
1735 if (!capable(CFS_CAP_SYS_ADMIN))
1736 return -EPERM;
1737
1738 rc = copy_and_ioctl(cmd, sbi->ll_md_exp, (void __user *)arg,
1739 sizeof(struct ioc_changelog));
1740 return rc;
1741 case OBD_IOC_FID2PATH:
1742 return ll_fid2path(inode, (void __user *)arg);
1743 case LL_IOC_HSM_REQUEST: {
1744 struct hsm_user_request *hur;
1745 ssize_t totalsize;
1746
1747 hur = memdup_user((void __user *)arg, sizeof(*hur));
1748 if (IS_ERR(hur))
1749 return PTR_ERR(hur);
1750
1751
1752 totalsize = hur_len(hur);
1753 kfree(hur);
1754 if (totalsize < 0)
1755 return -E2BIG;
1756
1757
1758 if (totalsize >= MDS_MAXREQSIZE / 3)
1759 return -E2BIG;
1760
1761 hur = libcfs_kvzalloc(totalsize, GFP_NOFS);
1762 if (!hur)
1763 return -ENOMEM;
1764
1765
1766 if (copy_from_user(hur, (void __user *)arg, totalsize)) {
1767 kvfree(hur);
1768 return -EFAULT;
1769 }
1770
1771 if (hur->hur_request.hr_action == HUA_RELEASE) {
1772 const struct lu_fid *fid;
1773 struct inode *f;
1774 int i;
1775
1776 for (i = 0; i < hur->hur_request.hr_itemcount; i++) {
1777 fid = &hur->hur_user_item[i].hui_fid;
1778 f = search_inode_for_lustre(inode->i_sb, fid);
1779 if (IS_ERR(f)) {
1780 rc = PTR_ERR(f);
1781 break;
1782 }
1783
1784 rc = ll_hsm_release(f);
1785 iput(f);
1786 if (rc != 0)
1787 break;
1788 }
1789 } else {
1790 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), totalsize,
1791 hur, NULL);
1792 }
1793
1794 kvfree(hur);
1795
1796 return rc;
1797 }
1798 case LL_IOC_HSM_PROGRESS: {
1799 struct hsm_progress_kernel hpk;
1800 struct hsm_progress hp;
1801
1802 if (copy_from_user(&hp, (void __user *)arg, sizeof(hp)))
1803 return -EFAULT;
1804
1805 hpk.hpk_fid = hp.hp_fid;
1806 hpk.hpk_cookie = hp.hp_cookie;
1807 hpk.hpk_extent = hp.hp_extent;
1808 hpk.hpk_flags = hp.hp_flags;
1809 hpk.hpk_errval = hp.hp_errval;
1810 hpk.hpk_data_version = 0;
1811
1812
1813
1814
1815 rc = obd_iocontrol(cmd, sbi->ll_md_exp, sizeof(hpk), &hpk,
1816 NULL);
1817 return rc;
1818 }
1819 case LL_IOC_HSM_CT_START:
1820 rc = copy_and_ioctl(cmd, sbi->ll_md_exp, (void __user *)arg,
1821 sizeof(struct lustre_kernelcomm));
1822 return rc;
1823
1824 case LL_IOC_HSM_COPY_START: {
1825 struct hsm_copy *copy;
1826 int rc;
1827
1828 copy = memdup_user((char __user *)arg, sizeof(*copy));
1829 if (IS_ERR(copy))
1830 return PTR_ERR(copy);
1831
1832 rc = ll_ioc_copy_start(inode->i_sb, copy);
1833 if (copy_to_user((char __user *)arg, copy, sizeof(*copy)))
1834 rc = -EFAULT;
1835
1836 kfree(copy);
1837 return rc;
1838 }
1839 case LL_IOC_HSM_COPY_END: {
1840 struct hsm_copy *copy;
1841 int rc;
1842
1843 copy = memdup_user((char __user *)arg, sizeof(*copy));
1844 if (IS_ERR(copy))
1845 return PTR_ERR(copy);
1846
1847 rc = ll_ioc_copy_end(inode->i_sb, copy);
1848 if (copy_to_user((char __user *)arg, copy, sizeof(*copy)))
1849 rc = -EFAULT;
1850
1851 kfree(copy);
1852 return rc;
1853 }
1854 default:
1855 return obd_iocontrol(cmd, sbi->ll_dt_exp, 0, NULL,
1856 (void __user *)arg);
1857 }
1858}
1859
1860static loff_t ll_dir_seek(struct file *file, loff_t offset, int origin)
1861{
1862 struct inode *inode = file->f_mapping->host;
1863 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
1864 struct ll_sb_info *sbi = ll_i2sbi(inode);
1865 int api32 = ll_need_32bit_api(sbi);
1866 loff_t ret = -EINVAL;
1867
1868 inode_lock(inode);
1869 switch (origin) {
1870 case SEEK_SET:
1871 break;
1872 case SEEK_CUR:
1873 offset += file->f_pos;
1874 break;
1875 case SEEK_END:
1876 if (offset > 0)
1877 goto out;
1878 if (api32)
1879 offset += LL_DIR_END_OFF_32BIT;
1880 else
1881 offset += LL_DIR_END_OFF;
1882 break;
1883 default:
1884 goto out;
1885 }
1886
1887 if (offset >= 0 &&
1888 ((api32 && offset <= LL_DIR_END_OFF_32BIT) ||
1889 (!api32 && offset <= LL_DIR_END_OFF))) {
1890 if (offset != file->f_pos) {
1891 if ((api32 && offset == LL_DIR_END_OFF_32BIT) ||
1892 (!api32 && offset == LL_DIR_END_OFF))
1893 fd->lfd_pos = MDS_DIR_END_OFF;
1894 else if (api32 && sbi->ll_flags & LL_SBI_64BIT_HASH)
1895 fd->lfd_pos = offset << 32;
1896 else
1897 fd->lfd_pos = offset;
1898 file->f_pos = offset;
1899 file->f_version = 0;
1900 }
1901 ret = offset;
1902 }
1903 goto out;
1904
1905out:
1906 inode_unlock(inode);
1907 return ret;
1908}
1909
1910static int ll_dir_open(struct inode *inode, struct file *file)
1911{
1912 return ll_file_open(inode, file);
1913}
1914
1915static int ll_dir_release(struct inode *inode, struct file *file)
1916{
1917 return ll_file_release(inode, file);
1918}
1919
1920const struct file_operations ll_dir_operations = {
1921 .llseek = ll_dir_seek,
1922 .open = ll_dir_open,
1923 .release = ll_dir_release,
1924 .read = generic_read_dir,
1925 .iterate = ll_readdir,
1926 .unlocked_ioctl = ll_dir_ioctl,
1927 .fsync = ll_fsync,
1928};
1929