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
42
43#define DEBUG_SUBSYSTEM S_LLITE
44#include <lustre_dlm.h>
45#include <lustre_lite.h>
46#include <linux/pagemap.h>
47#include <linux/file.h>
48#include "llite_internal.h"
49#include <lustre/ll_fiemap.h>
50
51#include "cl_object.h"
52
53struct ll_file_data *ll_file_data_get(void)
54{
55 struct ll_file_data *fd;
56
57 OBD_SLAB_ALLOC_PTR_GFP(fd, ll_file_data_slab, __GFP_IO);
58 if (fd == NULL)
59 return NULL;
60 fd->fd_write_failed = false;
61 return fd;
62}
63
64static void ll_file_data_put(struct ll_file_data *fd)
65{
66 if (fd != NULL)
67 OBD_SLAB_FREE_PTR(fd, ll_file_data_slab);
68}
69
70void ll_pack_inode2opdata(struct inode *inode, struct md_op_data *op_data,
71 struct lustre_handle *fh)
72{
73 op_data->op_fid1 = ll_i2info(inode)->lli_fid;
74 op_data->op_attr.ia_mode = inode->i_mode;
75 op_data->op_attr.ia_atime = inode->i_atime;
76 op_data->op_attr.ia_mtime = inode->i_mtime;
77 op_data->op_attr.ia_ctime = inode->i_ctime;
78 op_data->op_attr.ia_size = i_size_read(inode);
79 op_data->op_attr_blocks = inode->i_blocks;
80 ((struct ll_iattr *)&op_data->op_attr)->ia_attr_flags =
81 ll_inode_to_ext_flags(inode->i_flags);
82 op_data->op_ioepoch = ll_i2info(inode)->lli_ioepoch;
83 if (fh)
84 op_data->op_handle = *fh;
85 op_data->op_capa1 = ll_mdscapa_get(inode);
86
87 if (LLIF_DATA_MODIFIED & ll_i2info(inode)->lli_flags)
88 op_data->op_bias |= MDS_DATA_MODIFIED;
89}
90
91
92
93
94
95static void ll_prepare_close(struct inode *inode, struct md_op_data *op_data,
96 struct obd_client_handle *och)
97{
98 op_data->op_attr.ia_valid = ATTR_MODE | ATTR_ATIME | ATTR_ATIME_SET |
99 ATTR_MTIME | ATTR_MTIME_SET |
100 ATTR_CTIME | ATTR_CTIME_SET;
101
102 if (!(och->och_flags & FMODE_WRITE))
103 goto out;
104
105 if (!exp_connect_som(ll_i2mdexp(inode)) || !S_ISREG(inode->i_mode))
106 op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS;
107 else
108 ll_ioepoch_close(inode, op_data, &och, 0);
109
110out:
111 ll_pack_inode2opdata(inode, op_data, &och->och_fh);
112 ll_prep_md_op_data(op_data, inode, NULL, NULL,
113 0, 0, LUSTRE_OPC_ANY, NULL);
114}
115
116static int ll_close_inode_openhandle(struct obd_export *md_exp,
117 struct inode *inode,
118 struct obd_client_handle *och)
119{
120 struct obd_export *exp = ll_i2mdexp(inode);
121 struct md_op_data *op_data;
122 struct ptlrpc_request *req = NULL;
123 struct obd_device *obd = class_exp2obd(exp);
124 int epoch_close = 1;
125 int rc;
126
127 if (obd == NULL) {
128
129
130
131
132 CERROR("Invalid MDC connection handle "LPX64"\n",
133 ll_i2mdexp(inode)->exp_handle.h_cookie);
134 GOTO(out, rc = 0);
135 }
136
137 OBD_ALLOC_PTR(op_data);
138 if (op_data == NULL)
139 GOTO(out, rc = -ENOMEM);
140
141 ll_prepare_close(inode, op_data, och);
142 epoch_close = (op_data->op_flags & MF_EPOCH_CLOSE);
143 rc = md_close(md_exp, op_data, och->och_mod, &req);
144 if (rc == -EAGAIN) {
145
146 LASSERT(epoch_close);
147
148
149 rc = ll_som_update(inode, op_data);
150 if (rc) {
151 CERROR("inode %lu mdc Size-on-MDS update failed: "
152 "rc = %d\n", inode->i_ino, rc);
153 rc = 0;
154 }
155 } else if (rc) {
156 CERROR("inode %lu mdc close failed: rc = %d\n",
157 inode->i_ino, rc);
158 }
159
160
161
162 if (rc == 0 && (op_data->op_bias & MDS_DATA_MODIFIED)) {
163 struct ll_inode_info *lli = ll_i2info(inode);
164
165 spin_lock(&lli->lli_lock);
166 lli->lli_flags &= ~LLIF_DATA_MODIFIED;
167 spin_unlock(&lli->lli_lock);
168 }
169
170 ll_finish_md_op_data(op_data);
171
172 if (rc == 0) {
173 rc = ll_objects_destroy(req, inode);
174 if (rc)
175 CERROR("inode %lu ll_objects destroy: rc = %d\n",
176 inode->i_ino, rc);
177 }
178
179out:
180 if (exp_connect_som(exp) && !epoch_close &&
181 S_ISREG(inode->i_mode) && (och->och_flags & FMODE_WRITE)) {
182 ll_queue_done_writing(inode, LLIF_DONE_WRITING);
183 } else {
184 md_clear_open_replay_data(md_exp, och);
185
186 och->och_fh.cookie = DEAD_HANDLE_MAGIC;
187 OBD_FREE_PTR(och);
188 }
189 if (req)
190 ptlrpc_req_finished(req);
191 return rc;
192}
193
194int ll_md_real_close(struct inode *inode, int flags)
195{
196 struct ll_inode_info *lli = ll_i2info(inode);
197 struct obd_client_handle **och_p;
198 struct obd_client_handle *och;
199 __u64 *och_usecount;
200 int rc = 0;
201
202 if (flags & FMODE_WRITE) {
203 och_p = &lli->lli_mds_write_och;
204 och_usecount = &lli->lli_open_fd_write_count;
205 } else if (flags & FMODE_EXEC) {
206 och_p = &lli->lli_mds_exec_och;
207 och_usecount = &lli->lli_open_fd_exec_count;
208 } else {
209 LASSERT(flags & FMODE_READ);
210 och_p = &lli->lli_mds_read_och;
211 och_usecount = &lli->lli_open_fd_read_count;
212 }
213
214 mutex_lock(&lli->lli_och_mutex);
215 if (*och_usecount) {
216
217 mutex_unlock(&lli->lli_och_mutex);
218 return 0;
219 }
220 och=*och_p;
221 *och_p = NULL;
222 mutex_unlock(&lli->lli_och_mutex);
223
224 if (och) {
225
226 rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp,
227 inode, och);
228 }
229
230 return rc;
231}
232
233int ll_md_close(struct obd_export *md_exp, struct inode *inode,
234 struct file *file)
235{
236 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
237 struct ll_inode_info *lli = ll_i2info(inode);
238 int rc = 0;
239
240
241 if (unlikely(fd->fd_flags & LL_FILE_GROUP_LOCKED))
242 ll_put_grouplock(inode, file, fd->fd_grouplock.cg_gid);
243
244
245
246 if (file->f_dentry->d_inode) {
247 int lockmode;
248 int flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_TEST_LOCK;
249 struct lustre_handle lockh;
250 struct inode *inode = file->f_dentry->d_inode;
251 ldlm_policy_data_t policy = {.l_inodebits={MDS_INODELOCK_OPEN}};
252
253 mutex_lock(&lli->lli_och_mutex);
254 if (fd->fd_omode & FMODE_WRITE) {
255 lockmode = LCK_CW;
256 LASSERT(lli->lli_open_fd_write_count);
257 lli->lli_open_fd_write_count--;
258 } else if (fd->fd_omode & FMODE_EXEC) {
259 lockmode = LCK_PR;
260 LASSERT(lli->lli_open_fd_exec_count);
261 lli->lli_open_fd_exec_count--;
262 } else {
263 lockmode = LCK_CR;
264 LASSERT(lli->lli_open_fd_read_count);
265 lli->lli_open_fd_read_count--;
266 }
267 mutex_unlock(&lli->lli_och_mutex);
268
269 if (!md_lock_match(md_exp, flags, ll_inode2fid(inode),
270 LDLM_IBITS, &policy, lockmode,
271 &lockh)) {
272 rc = ll_md_real_close(file->f_dentry->d_inode,
273 fd->fd_omode);
274 }
275 } else {
276 CERROR("Releasing a file %p with negative dentry %p. Name %s",
277 file, file->f_dentry, file->f_dentry->d_name.name);
278 }
279
280 LUSTRE_FPRIVATE(file) = NULL;
281 ll_file_data_put(fd);
282 ll_capa_close(inode);
283
284 return rc;
285}
286
287
288
289
290
291
292int ll_file_release(struct inode *inode, struct file *file)
293{
294 struct ll_file_data *fd;
295 struct ll_sb_info *sbi = ll_i2sbi(inode);
296 struct ll_inode_info *lli = ll_i2info(inode);
297 int rc;
298
299 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
300 inode->i_generation, inode);
301
302#ifdef CONFIG_FS_POSIX_ACL
303 if (sbi->ll_flags & LL_SBI_RMT_CLIENT &&
304 inode == inode->i_sb->s_root->d_inode) {
305 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
306
307 LASSERT(fd != NULL);
308 if (unlikely(fd->fd_flags & LL_FILE_RMTACL)) {
309 fd->fd_flags &= ~LL_FILE_RMTACL;
310 rct_del(&sbi->ll_rct, current_pid());
311 et_search_free(&sbi->ll_et, current_pid());
312 }
313 }
314#endif
315
316 if (inode->i_sb->s_root != file->f_dentry)
317 ll_stats_ops_tally(sbi, LPROC_LL_RELEASE, 1);
318 fd = LUSTRE_FPRIVATE(file);
319 LASSERT(fd != NULL);
320
321
322
323
324 if (S_ISDIR(inode->i_mode) && lli->lli_opendir_key == fd &&
325 lli->lli_opendir_pid != 0)
326 ll_stop_statahead(inode, lli->lli_opendir_key);
327
328 if (inode->i_sb->s_root == file->f_dentry) {
329 LUSTRE_FPRIVATE(file) = NULL;
330 ll_file_data_put(fd);
331 return 0;
332 }
333
334 if (!S_ISDIR(inode->i_mode)) {
335 lov_read_and_clear_async_rc(lli->lli_clob);
336 lli->lli_async_rc = 0;
337 }
338
339 rc = ll_md_close(sbi->ll_md_exp, inode, file);
340
341 if (CFS_FAIL_TIMEOUT_MS(OBD_FAIL_PTLRPC_DUMP_LOG, cfs_fail_val))
342 libcfs_debug_dumplog();
343
344 return rc;
345}
346
347static int ll_intent_file_open(struct file *file, void *lmm,
348 int lmmsize, struct lookup_intent *itp)
349{
350 struct ll_sb_info *sbi = ll_i2sbi(file->f_dentry->d_inode);
351 struct dentry *parent = file->f_dentry->d_parent;
352 const char *name = file->f_dentry->d_name.name;
353 const int len = file->f_dentry->d_name.len;
354 struct md_op_data *op_data;
355 struct ptlrpc_request *req;
356 __u32 opc = LUSTRE_OPC_ANY;
357 int rc;
358
359 if (!parent)
360 return -ENOENT;
361
362
363
364
365
366
367
368
369
370
371 if (lmm == NULL && lmmsize == 0) {
372 itp->it_flags |= MDS_OPEN_LOCK;
373 if (itp->it_flags & FMODE_WRITE)
374 opc = LUSTRE_OPC_CREATE;
375 }
376
377 op_data = ll_prep_md_op_data(NULL, parent->d_inode,
378 file->f_dentry->d_inode, name, len,
379 O_RDWR, opc, NULL);
380 if (IS_ERR(op_data))
381 return PTR_ERR(op_data);
382
383 itp->it_flags |= MDS_OPEN_BY_FID;
384 rc = md_intent_lock(sbi->ll_md_exp, op_data, lmm, lmmsize, itp,
385 0 , &req, ll_md_blocking_ast, 0);
386 ll_finish_md_op_data(op_data);
387 if (rc == -ESTALE) {
388
389
390
391 if (!it_disposition(itp, DISP_OPEN_OPEN) ||
392 it_open_error(DISP_OPEN_OPEN, itp))
393 GOTO(out, rc);
394 ll_release_openhandle(file->f_dentry, itp);
395 GOTO(out, rc);
396 }
397
398 if (it_disposition(itp, DISP_LOOKUP_NEG))
399 GOTO(out, rc = -ENOENT);
400
401 if (rc != 0 || it_open_error(DISP_OPEN_OPEN, itp)) {
402 rc = rc ? rc : it_open_error(DISP_OPEN_OPEN, itp);
403 CDEBUG(D_VFSTRACE, "lock enqueue: err: %d\n", rc);
404 GOTO(out, rc);
405 }
406
407 rc = ll_prep_inode(&file->f_dentry->d_inode, req, NULL, itp);
408 if (!rc && itp->d.lustre.it_lock_mode)
409 ll_set_lock_data(sbi->ll_md_exp, file->f_dentry->d_inode,
410 itp, NULL);
411
412out:
413 ptlrpc_req_finished(itp->d.lustre.it_data);
414 it_clear_disposition(itp, DISP_ENQ_COMPLETE);
415 ll_intent_drop_lock(itp);
416
417 return rc;
418}
419
420
421
422
423
424
425void ll_ioepoch_open(struct ll_inode_info *lli, __u64 ioepoch)
426{
427 if (ioepoch && lli->lli_ioepoch != ioepoch) {
428 lli->lli_ioepoch = ioepoch;
429 CDEBUG(D_INODE, "Epoch "LPU64" opened on "DFID"\n",
430 ioepoch, PFID(&lli->lli_fid));
431 }
432}
433
434static int ll_och_fill(struct obd_export *md_exp, struct ll_inode_info *lli,
435 struct lookup_intent *it, struct obd_client_handle *och)
436{
437 struct ptlrpc_request *req = it->d.lustre.it_data;
438 struct mdt_body *body;
439
440 LASSERT(och);
441
442 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
443 LASSERT(body != NULL);
444
445 memcpy(&och->och_fh, &body->handle, sizeof(body->handle));
446 och->och_magic = OBD_CLIENT_HANDLE_MAGIC;
447 och->och_fid = lli->lli_fid;
448 och->och_flags = it->it_flags;
449 ll_ioepoch_open(lli, body->ioepoch);
450
451 return md_set_open_replay_data(md_exp, och, req);
452}
453
454int ll_local_open(struct file *file, struct lookup_intent *it,
455 struct ll_file_data *fd, struct obd_client_handle *och)
456{
457 struct inode *inode = file->f_dentry->d_inode;
458 struct ll_inode_info *lli = ll_i2info(inode);
459
460 LASSERT(!LUSTRE_FPRIVATE(file));
461
462 LASSERT(fd != NULL);
463
464 if (och) {
465 struct ptlrpc_request *req = it->d.lustre.it_data;
466 struct mdt_body *body;
467 int rc;
468
469 rc = ll_och_fill(ll_i2sbi(inode)->ll_md_exp, lli, it, och);
470 if (rc)
471 return rc;
472
473 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
474 if ((it->it_flags & FMODE_WRITE) &&
475 (body->valid & OBD_MD_FLSIZE))
476 CDEBUG(D_INODE, "Epoch "LPU64" opened on "DFID"\n",
477 lli->lli_ioepoch, PFID(&lli->lli_fid));
478 }
479
480 LUSTRE_FPRIVATE(file) = fd;
481 ll_readahead_init(inode, &fd->fd_ras);
482 fd->fd_omode = it->it_flags;
483 return 0;
484}
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499int ll_file_open(struct inode *inode, struct file *file)
500{
501 struct ll_inode_info *lli = ll_i2info(inode);
502 struct lookup_intent *it, oit = { .it_op = IT_OPEN,
503 .it_flags = file->f_flags };
504 struct obd_client_handle **och_p = NULL;
505 __u64 *och_usecount = NULL;
506 struct ll_file_data *fd;
507 int rc = 0, opendir_set = 0;
508
509 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), flags %o\n", inode->i_ino,
510 inode->i_generation, inode, file->f_flags);
511
512 it = file->private_data;
513 file->private_data = NULL;
514
515 fd = ll_file_data_get();
516 if (fd == NULL)
517 GOTO(out_openerr, rc = -ENOMEM);
518
519 fd->fd_file = file;
520 if (S_ISDIR(inode->i_mode)) {
521 spin_lock(&lli->lli_sa_lock);
522 if (lli->lli_opendir_key == NULL && lli->lli_sai == NULL &&
523 lli->lli_opendir_pid == 0) {
524 lli->lli_opendir_key = fd;
525 lli->lli_opendir_pid = current_pid();
526 opendir_set = 1;
527 }
528 spin_unlock(&lli->lli_sa_lock);
529 }
530
531 if (inode->i_sb->s_root == file->f_dentry) {
532 LUSTRE_FPRIVATE(file) = fd;
533 return 0;
534 }
535
536 if (!it || !it->d.lustre.it_disposition) {
537
538
539
540 if ((oit.it_flags + 1) & O_ACCMODE)
541 oit.it_flags++;
542 if (file->f_flags & O_TRUNC)
543 oit.it_flags |= FMODE_WRITE;
544
545
546
547
548
549 if (oit.it_flags & (FMODE_WRITE | FMODE_READ))
550 oit.it_flags |= MDS_OPEN_OWNEROVERRIDE;
551
552
553
554 oit.it_flags &= ~O_EXCL;
555
556
557
558
559 if (oit.it_flags & O_CREAT)
560 oit.it_op |= IT_CREAT;
561
562 it = &oit;
563 }
564
565restart:
566
567 if (it->it_flags & FMODE_WRITE) {
568 och_p = &lli->lli_mds_write_och;
569 och_usecount = &lli->lli_open_fd_write_count;
570 } else if (it->it_flags & FMODE_EXEC) {
571 och_p = &lli->lli_mds_exec_och;
572 och_usecount = &lli->lli_open_fd_exec_count;
573 } else {
574 och_p = &lli->lli_mds_read_och;
575 och_usecount = &lli->lli_open_fd_read_count;
576 }
577
578 mutex_lock(&lli->lli_och_mutex);
579 if (*och_p) {
580 if (it_disposition(it, DISP_OPEN_OPEN)) {
581
582
583 rc = it_open_error(DISP_OPEN_OPEN, it);
584 if (rc) {
585 mutex_unlock(&lli->lli_och_mutex);
586 GOTO(out_openerr, rc);
587 }
588
589 ll_release_openhandle(file->f_dentry, it);
590 }
591 (*och_usecount)++;
592
593 rc = ll_local_open(file, it, fd, NULL);
594 if (rc) {
595 (*och_usecount)--;
596 mutex_unlock(&lli->lli_och_mutex);
597 GOTO(out_openerr, rc);
598 }
599 } else {
600 LASSERT(*och_usecount == 0);
601 if (!it->d.lustre.it_disposition) {
602
603
604
605
606
607 mutex_unlock(&lli->lli_och_mutex);
608 it->it_create_mode |= M_CHECK_STALE;
609 rc = ll_intent_file_open(file, NULL, 0, it);
610 it->it_create_mode &= ~M_CHECK_STALE;
611 if (rc)
612 GOTO(out_openerr, rc);
613
614 goto restart;
615 }
616 OBD_ALLOC(*och_p, sizeof (struct obd_client_handle));
617 if (!*och_p)
618 GOTO(out_och_free, rc = -ENOMEM);
619
620 (*och_usecount)++;
621
622
623
624
625
626
627 rc = it_open_error(DISP_OPEN_OPEN, it);
628 if (rc)
629 GOTO(out_och_free, rc);
630
631 LASSERT(it_disposition(it, DISP_ENQ_OPEN_REF));
632
633 rc = ll_local_open(file, it, fd, *och_p);
634 if (rc)
635 GOTO(out_och_free, rc);
636 }
637 mutex_unlock(&lli->lli_och_mutex);
638 fd = NULL;
639
640
641
642
643 if (!S_ISREG(inode->i_mode))
644 GOTO(out_och_free, rc);
645
646 ll_capa_open(inode);
647
648 if (!lli->lli_has_smd) {
649 if (file->f_flags & O_LOV_DELAY_CREATE ||
650 !(file->f_mode & FMODE_WRITE)) {
651 CDEBUG(D_INODE, "object creation was delayed\n");
652 GOTO(out_och_free, rc);
653 }
654 }
655 file->f_flags &= ~O_LOV_DELAY_CREATE;
656 GOTO(out_och_free, rc);
657
658out_och_free:
659 if (rc) {
660 if (och_p && *och_p) {
661 OBD_FREE(*och_p, sizeof (struct obd_client_handle));
662 *och_p = NULL;
663 (*och_usecount)--;
664 }
665 mutex_unlock(&lli->lli_och_mutex);
666
667out_openerr:
668 if (opendir_set != 0)
669 ll_stop_statahead(inode, lli->lli_opendir_key);
670 if (fd != NULL)
671 ll_file_data_put(fd);
672 } else {
673 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_OPEN, 1);
674 }
675
676 if (it && it_disposition(it, DISP_ENQ_OPEN_REF)) {
677 ptlrpc_req_finished(it->d.lustre.it_data);
678 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
679 }
680
681 return rc;
682}
683
684
685static int ll_lsm_getattr(struct lov_stripe_md *lsm, struct obd_export *exp,
686 struct obd_capa *capa, struct obdo *obdo,
687 __u64 ioepoch, int sync)
688{
689 struct ptlrpc_request_set *set;
690 struct obd_info oinfo = { { { 0 } } };
691 int rc;
692
693 LASSERT(lsm != NULL);
694
695 oinfo.oi_md = lsm;
696 oinfo.oi_oa = obdo;
697 oinfo.oi_oa->o_oi = lsm->lsm_oi;
698 oinfo.oi_oa->o_mode = S_IFREG;
699 oinfo.oi_oa->o_ioepoch = ioepoch;
700 oinfo.oi_oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE |
701 OBD_MD_FLSIZE | OBD_MD_FLBLOCKS |
702 OBD_MD_FLBLKSZ | OBD_MD_FLATIME |
703 OBD_MD_FLMTIME | OBD_MD_FLCTIME |
704 OBD_MD_FLGROUP | OBD_MD_FLEPOCH |
705 OBD_MD_FLDATAVERSION;
706 oinfo.oi_capa = capa;
707 if (sync) {
708 oinfo.oi_oa->o_valid |= OBD_MD_FLFLAGS;
709 oinfo.oi_oa->o_flags |= OBD_FL_SRVLOCK;
710 }
711
712 set = ptlrpc_prep_set();
713 if (set == NULL) {
714 CERROR("can't allocate ptlrpc set\n");
715 rc = -ENOMEM;
716 } else {
717 rc = obd_getattr_async(exp, &oinfo, set);
718 if (rc == 0)
719 rc = ptlrpc_set_wait(set);
720 ptlrpc_set_destroy(set);
721 }
722 if (rc == 0)
723 oinfo.oi_oa->o_valid &= (OBD_MD_FLBLOCKS | OBD_MD_FLBLKSZ |
724 OBD_MD_FLATIME | OBD_MD_FLMTIME |
725 OBD_MD_FLCTIME | OBD_MD_FLSIZE |
726 OBD_MD_FLDATAVERSION);
727 return rc;
728}
729
730
731
732
733
734int ll_inode_getattr(struct inode *inode, struct obdo *obdo,
735 __u64 ioepoch, int sync)
736{
737 struct obd_capa *capa = ll_mdscapa_get(inode);
738 struct lov_stripe_md *lsm;
739 int rc;
740
741 lsm = ccc_inode_lsm_get(inode);
742 rc = ll_lsm_getattr(lsm, ll_i2dtexp(inode),
743 capa, obdo, ioepoch, sync);
744 capa_put(capa);
745 if (rc == 0) {
746 struct ost_id *oi = lsm ? &lsm->lsm_oi : &obdo->o_oi;
747
748 obdo_refresh_inode(inode, obdo, obdo->o_valid);
749 CDEBUG(D_INODE, "objid "DOSTID" size %llu, blocks %llu,"
750 " blksize %lu\n", POSTID(oi), i_size_read(inode),
751 (unsigned long long)inode->i_blocks,
752 (unsigned long)ll_inode_blksize(inode));
753 }
754 ccc_inode_lsm_put(inode, lsm);
755 return rc;
756}
757
758int ll_merge_lvb(const struct lu_env *env, struct inode *inode)
759{
760 struct ll_inode_info *lli = ll_i2info(inode);
761 struct cl_object *obj = lli->lli_clob;
762 struct cl_attr *attr = ccc_env_thread_attr(env);
763 struct ost_lvb lvb;
764 int rc = 0;
765
766 ll_inode_size_lock(inode);
767
768
769 LTIME_S(inode->i_atime) = lli->lli_lvb.lvb_atime;
770 LTIME_S(inode->i_mtime) = lli->lli_lvb.lvb_mtime;
771 LTIME_S(inode->i_ctime) = lli->lli_lvb.lvb_ctime;
772 inode_init_lvb(inode, &lvb);
773
774 cl_object_attr_lock(obj);
775 rc = cl_object_attr_get(env, obj, attr);
776 cl_object_attr_unlock(obj);
777
778 if (rc == 0) {
779 if (lvb.lvb_atime < attr->cat_atime)
780 lvb.lvb_atime = attr->cat_atime;
781 if (lvb.lvb_ctime < attr->cat_ctime)
782 lvb.lvb_ctime = attr->cat_ctime;
783 if (lvb.lvb_mtime < attr->cat_mtime)
784 lvb.lvb_mtime = attr->cat_mtime;
785
786 CDEBUG(D_VFSTRACE, DFID" updating i_size "LPU64"\n",
787 PFID(&lli->lli_fid), attr->cat_size);
788 cl_isize_write_nolock(inode, attr->cat_size);
789
790 inode->i_blocks = attr->cat_blocks;
791
792 LTIME_S(inode->i_mtime) = lvb.lvb_mtime;
793 LTIME_S(inode->i_atime) = lvb.lvb_atime;
794 LTIME_S(inode->i_ctime) = lvb.lvb_ctime;
795 }
796 ll_inode_size_unlock(inode);
797
798 return rc;
799}
800
801int ll_glimpse_ioctl(struct ll_sb_info *sbi, struct lov_stripe_md *lsm,
802 lstat_t *st)
803{
804 struct obdo obdo = { 0 };
805 int rc;
806
807 rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, &obdo, 0, 0);
808 if (rc == 0) {
809 st->st_size = obdo.o_size;
810 st->st_blocks = obdo.o_blocks;
811 st->st_mtime = obdo.o_mtime;
812 st->st_atime = obdo.o_atime;
813 st->st_ctime = obdo.o_ctime;
814 }
815 return rc;
816}
817
818void ll_io_init(struct cl_io *io, const struct file *file, int write)
819{
820 struct inode *inode = file->f_dentry->d_inode;
821
822 io->u.ci_rw.crw_nonblock = file->f_flags & O_NONBLOCK;
823 if (write) {
824 io->u.ci_wr.wr_append = !!(file->f_flags & O_APPEND);
825 io->u.ci_wr.wr_sync = file->f_flags & O_SYNC ||
826 file->f_flags & O_DIRECT ||
827 IS_SYNC(inode);
828 }
829 io->ci_obj = ll_i2info(inode)->lli_clob;
830 io->ci_lockreq = CILR_MAYBE;
831 if (ll_file_nolock(file)) {
832 io->ci_lockreq = CILR_NEVER;
833 io->ci_no_srvlock = 1;
834 } else if (file->f_flags & O_APPEND) {
835 io->ci_lockreq = CILR_MANDATORY;
836 }
837}
838
839static ssize_t
840ll_file_io_generic(const struct lu_env *env, struct vvp_io_args *args,
841 struct file *file, enum cl_io_type iot,
842 loff_t *ppos, size_t count)
843{
844 struct ll_inode_info *lli = ll_i2info(file->f_dentry->d_inode);
845 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
846 struct cl_io *io;
847 ssize_t result;
848
849restart:
850 io = ccc_env_thread_io(env);
851 ll_io_init(io, file, iot == CIT_WRITE);
852
853 if (cl_io_rw_init(env, io, iot, *ppos, count) == 0) {
854 struct vvp_io *vio = vvp_env_io(env);
855 struct ccc_io *cio = ccc_env_io(env);
856 int write_mutex_locked = 0;
857
858 cio->cui_fd = LUSTRE_FPRIVATE(file);
859 vio->cui_io_subtype = args->via_io_subtype;
860
861 switch (vio->cui_io_subtype) {
862 case IO_NORMAL:
863 cio->cui_iov = args->u.normal.via_iov;
864 cio->cui_nrsegs = args->u.normal.via_nrsegs;
865 cio->cui_tot_nrsegs = cio->cui_nrsegs;
866 cio->cui_iocb = args->u.normal.via_iocb;
867 if ((iot == CIT_WRITE) &&
868 !(cio->cui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
869 if (mutex_lock_interruptible(&lli->
870 lli_write_mutex))
871 GOTO(out, result = -ERESTARTSYS);
872 write_mutex_locked = 1;
873 } else if (iot == CIT_READ) {
874 down_read(&lli->lli_trunc_sem);
875 }
876 break;
877 case IO_SENDFILE:
878 vio->u.sendfile.cui_actor = args->u.sendfile.via_actor;
879 vio->u.sendfile.cui_target = args->u.sendfile.via_target;
880 break;
881 case IO_SPLICE:
882 vio->u.splice.cui_pipe = args->u.splice.via_pipe;
883 vio->u.splice.cui_flags = args->u.splice.via_flags;
884 break;
885 default:
886 CERROR("Unknow IO type - %u\n", vio->cui_io_subtype);
887 LBUG();
888 }
889 result = cl_io_loop(env, io);
890 if (write_mutex_locked)
891 mutex_unlock(&lli->lli_write_mutex);
892 else if (args->via_io_subtype == IO_NORMAL && iot == CIT_READ)
893 up_read(&lli->lli_trunc_sem);
894 } else {
895
896 result = io->ci_result;
897 }
898
899 if (io->ci_nob > 0) {
900 result = io->ci_nob;
901 *ppos = io->u.ci_wr.wr.crw_pos;
902 }
903 GOTO(out, result);
904out:
905 cl_io_fini(env, io);
906
907
908 if (result == 0 && io->ci_need_restart) {
909 CDEBUG(D_VFSTRACE, "Restart %s on %s from %lld, count:%zd\n",
910 iot == CIT_READ ? "read" : "write",
911 file->f_dentry->d_name.name, *ppos, count);
912 LASSERTF(io->ci_nob == 0, "%zd", io->ci_nob);
913 goto restart;
914 }
915
916 if (iot == CIT_READ) {
917 if (result >= 0)
918 ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode),
919 LPROC_LL_READ_BYTES, result);
920 } else if (iot == CIT_WRITE) {
921 if (result >= 0) {
922 ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode),
923 LPROC_LL_WRITE_BYTES, result);
924 fd->fd_write_failed = false;
925 } else if (result != -ERESTARTSYS) {
926 fd->fd_write_failed = true;
927 }
928 }
929
930 return result;
931}
932
933
934
935
936
937static int ll_file_get_iov_count(const struct iovec *iov,
938 unsigned long *nr_segs, size_t *count)
939{
940 size_t cnt = 0;
941 unsigned long seg;
942
943 for (seg = 0; seg < *nr_segs; seg++) {
944 const struct iovec *iv = &iov[seg];
945
946
947
948
949
950 cnt += iv->iov_len;
951 if (unlikely((ssize_t)(cnt|iv->iov_len) < 0))
952 return -EINVAL;
953 if (access_ok(VERIFY_READ, iv->iov_base, iv->iov_len))
954 continue;
955 if (seg == 0)
956 return -EFAULT;
957 *nr_segs = seg;
958 cnt -= iv->iov_len;
959 break;
960 }
961 *count = cnt;
962 return 0;
963}
964
965static ssize_t ll_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
966 unsigned long nr_segs, loff_t pos)
967{
968 struct lu_env *env;
969 struct vvp_io_args *args;
970 size_t count;
971 ssize_t result;
972 int refcheck;
973
974 result = ll_file_get_iov_count(iov, &nr_segs, &count);
975 if (result)
976 return result;
977
978 env = cl_env_get(&refcheck);
979 if (IS_ERR(env))
980 return PTR_ERR(env);
981
982 args = vvp_env_args(env, IO_NORMAL);
983 args->u.normal.via_iov = (struct iovec *)iov;
984 args->u.normal.via_nrsegs = nr_segs;
985 args->u.normal.via_iocb = iocb;
986
987 result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_READ,
988 &iocb->ki_pos, count);
989 cl_env_put(env, &refcheck);
990 return result;
991}
992
993static ssize_t ll_file_read(struct file *file, char *buf, size_t count,
994 loff_t *ppos)
995{
996 struct lu_env *env;
997 struct iovec *local_iov;
998 struct kiocb *kiocb;
999 ssize_t result;
1000 int refcheck;
1001
1002 env = cl_env_get(&refcheck);
1003 if (IS_ERR(env))
1004 return PTR_ERR(env);
1005
1006 local_iov = &vvp_env_info(env)->vti_local_iov;
1007 kiocb = &vvp_env_info(env)->vti_kiocb;
1008 local_iov->iov_base = (void __user *)buf;
1009 local_iov->iov_len = count;
1010 init_sync_kiocb(kiocb, file);
1011 kiocb->ki_pos = *ppos;
1012 kiocb->ki_nbytes = count;
1013
1014 result = ll_file_aio_read(kiocb, local_iov, 1, kiocb->ki_pos);
1015 *ppos = kiocb->ki_pos;
1016
1017 cl_env_put(env, &refcheck);
1018 return result;
1019}
1020
1021
1022
1023
1024static ssize_t ll_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
1025 unsigned long nr_segs, loff_t pos)
1026{
1027 struct lu_env *env;
1028 struct vvp_io_args *args;
1029 size_t count;
1030 ssize_t result;
1031 int refcheck;
1032
1033 result = ll_file_get_iov_count(iov, &nr_segs, &count);
1034 if (result)
1035 return result;
1036
1037 env = cl_env_get(&refcheck);
1038 if (IS_ERR(env))
1039 return PTR_ERR(env);
1040
1041 args = vvp_env_args(env, IO_NORMAL);
1042 args->u.normal.via_iov = (struct iovec *)iov;
1043 args->u.normal.via_nrsegs = nr_segs;
1044 args->u.normal.via_iocb = iocb;
1045
1046 result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_WRITE,
1047 &iocb->ki_pos, count);
1048 cl_env_put(env, &refcheck);
1049 return result;
1050}
1051
1052static ssize_t ll_file_write(struct file *file, const char *buf, size_t count,
1053 loff_t *ppos)
1054{
1055 struct lu_env *env;
1056 struct iovec *local_iov;
1057 struct kiocb *kiocb;
1058 ssize_t result;
1059 int refcheck;
1060
1061 env = cl_env_get(&refcheck);
1062 if (IS_ERR(env))
1063 return PTR_ERR(env);
1064
1065 local_iov = &vvp_env_info(env)->vti_local_iov;
1066 kiocb = &vvp_env_info(env)->vti_kiocb;
1067 local_iov->iov_base = (void __user *)buf;
1068 local_iov->iov_len = count;
1069 init_sync_kiocb(kiocb, file);
1070 kiocb->ki_pos = *ppos;
1071 kiocb->ki_nbytes = count;
1072
1073 result = ll_file_aio_write(kiocb, local_iov, 1, kiocb->ki_pos);
1074 *ppos = kiocb->ki_pos;
1075
1076 cl_env_put(env, &refcheck);
1077 return result;
1078}
1079
1080
1081
1082
1083
1084
1085static ssize_t ll_file_splice_read(struct file *in_file, loff_t *ppos,
1086 struct pipe_inode_info *pipe, size_t count,
1087 unsigned int flags)
1088{
1089 struct lu_env *env;
1090 struct vvp_io_args *args;
1091 ssize_t result;
1092 int refcheck;
1093
1094 env = cl_env_get(&refcheck);
1095 if (IS_ERR(env))
1096 return PTR_ERR(env);
1097
1098 args = vvp_env_args(env, IO_SPLICE);
1099 args->u.splice.via_pipe = pipe;
1100 args->u.splice.via_flags = flags;
1101
1102 result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count);
1103 cl_env_put(env, &refcheck);
1104 return result;
1105}
1106
1107static int ll_lov_recreate(struct inode *inode, struct ost_id *oi,
1108 obd_count ost_idx)
1109{
1110 struct obd_export *exp = ll_i2dtexp(inode);
1111 struct obd_trans_info oti = { 0 };
1112 struct obdo *oa = NULL;
1113 int lsm_size;
1114 int rc = 0;
1115 struct lov_stripe_md *lsm = NULL, *lsm2;
1116
1117 OBDO_ALLOC(oa);
1118 if (oa == NULL)
1119 return -ENOMEM;
1120
1121 lsm = ccc_inode_lsm_get(inode);
1122 if (!lsm_has_objects(lsm))
1123 GOTO(out, rc = -ENOENT);
1124
1125 lsm_size = sizeof(*lsm) + (sizeof(struct lov_oinfo) *
1126 (lsm->lsm_stripe_count));
1127
1128 OBD_ALLOC_LARGE(lsm2, lsm_size);
1129 if (lsm2 == NULL)
1130 GOTO(out, rc = -ENOMEM);
1131
1132 oa->o_oi = *oi;
1133 oa->o_nlink = ost_idx;
1134 oa->o_flags |= OBD_FL_RECREATE_OBJS;
1135 oa->o_valid = OBD_MD_FLID | OBD_MD_FLFLAGS | OBD_MD_FLGROUP;
1136 obdo_from_inode(oa, inode, OBD_MD_FLTYPE | OBD_MD_FLATIME |
1137 OBD_MD_FLMTIME | OBD_MD_FLCTIME);
1138 obdo_set_parent_fid(oa, &ll_i2info(inode)->lli_fid);
1139 memcpy(lsm2, lsm, lsm_size);
1140 ll_inode_size_lock(inode);
1141 rc = obd_create(NULL, exp, oa, &lsm2, &oti);
1142 ll_inode_size_unlock(inode);
1143
1144 OBD_FREE_LARGE(lsm2, lsm_size);
1145 GOTO(out, rc);
1146out:
1147 ccc_inode_lsm_put(inode, lsm);
1148 OBDO_FREE(oa);
1149 return rc;
1150}
1151
1152static int ll_lov_recreate_obj(struct inode *inode, unsigned long arg)
1153{
1154 struct ll_recreate_obj ucreat;
1155 struct ost_id oi;
1156
1157 if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1158 return -EPERM;
1159
1160 if (copy_from_user(&ucreat, (struct ll_recreate_obj *)arg,
1161 sizeof(ucreat)))
1162 return -EFAULT;
1163
1164 ostid_set_seq_mdt0(&oi);
1165 ostid_set_id(&oi, ucreat.lrc_id);
1166 return ll_lov_recreate(inode, &oi, ucreat.lrc_ost_idx);
1167}
1168
1169static int ll_lov_recreate_fid(struct inode *inode, unsigned long arg)
1170{
1171 struct lu_fid fid;
1172 struct ost_id oi;
1173 obd_count ost_idx;
1174
1175 if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1176 return -EPERM;
1177
1178 if (copy_from_user(&fid, (struct lu_fid *)arg, sizeof(fid)))
1179 return -EFAULT;
1180
1181 fid_to_ostid(&fid, &oi);
1182 ost_idx = (fid_seq(&fid) >> 16) & 0xffff;
1183 return ll_lov_recreate(inode, &oi, ost_idx);
1184}
1185
1186int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
1187 int flags, struct lov_user_md *lum, int lum_size)
1188{
1189 struct lov_stripe_md *lsm = NULL;
1190 struct lookup_intent oit = {.it_op = IT_OPEN, .it_flags = flags};
1191 int rc = 0;
1192
1193 lsm = ccc_inode_lsm_get(inode);
1194 if (lsm != NULL) {
1195 ccc_inode_lsm_put(inode, lsm);
1196 CDEBUG(D_IOCTL, "stripe already exists for ino %lu\n",
1197 inode->i_ino);
1198 return -EEXIST;
1199 }
1200
1201 ll_inode_size_lock(inode);
1202 rc = ll_intent_file_open(file, lum, lum_size, &oit);
1203 if (rc)
1204 GOTO(out, rc);
1205 rc = oit.d.lustre.it_status;
1206 if (rc < 0)
1207 GOTO(out_req_free, rc);
1208
1209 ll_release_openhandle(file->f_dentry, &oit);
1210
1211 out:
1212 ll_inode_size_unlock(inode);
1213 ll_intent_release(&oit);
1214 ccc_inode_lsm_put(inode, lsm);
1215 return rc;
1216out_req_free:
1217 ptlrpc_req_finished((struct ptlrpc_request *) oit.d.lustre.it_data);
1218 goto out;
1219}
1220
1221int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
1222 struct lov_mds_md **lmmp, int *lmm_size,
1223 struct ptlrpc_request **request)
1224{
1225 struct ll_sb_info *sbi = ll_i2sbi(inode);
1226 struct mdt_body *body;
1227 struct lov_mds_md *lmm = NULL;
1228 struct ptlrpc_request *req = NULL;
1229 struct md_op_data *op_data;
1230 int rc, lmmsize;
1231
1232 rc = ll_get_max_mdsize(sbi, &lmmsize);
1233 if (rc)
1234 return rc;
1235
1236 op_data = ll_prep_md_op_data(NULL, inode, NULL, filename,
1237 strlen(filename), lmmsize,
1238 LUSTRE_OPC_ANY, NULL);
1239 if (IS_ERR(op_data))
1240 return PTR_ERR(op_data);
1241
1242 op_data->op_valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA;
1243 rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
1244 ll_finish_md_op_data(op_data);
1245 if (rc < 0) {
1246 CDEBUG(D_INFO, "md_getattr_name failed "
1247 "on %s: rc %d\n", filename, rc);
1248 GOTO(out, rc);
1249 }
1250
1251 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
1252 LASSERT(body != NULL);
1253
1254 lmmsize = body->eadatasize;
1255
1256 if (!(body->valid & (OBD_MD_FLEASIZE | OBD_MD_FLDIREA)) ||
1257 lmmsize == 0) {
1258 GOTO(out, rc = -ENODATA);
1259 }
1260
1261 lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, lmmsize);
1262 LASSERT(lmm != NULL);
1263
1264 if ((lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V1)) &&
1265 (lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V3))) {
1266 GOTO(out, rc = -EPROTO);
1267 }
1268
1269
1270
1271
1272
1273
1274 if (LOV_MAGIC != cpu_to_le32(LOV_MAGIC)) {
1275 int stripe_count;
1276
1277 stripe_count = le16_to_cpu(lmm->lmm_stripe_count);
1278 if (le32_to_cpu(lmm->lmm_pattern) & LOV_PATTERN_F_RELEASED)
1279 stripe_count = 0;
1280
1281
1282
1283 if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) {
1284 lustre_swab_lov_user_md_v1((struct lov_user_md_v1 *)lmm);
1285 if (S_ISREG(body->mode))
1286 lustre_swab_lov_user_md_objects(
1287 ((struct lov_user_md_v1 *)lmm)->lmm_objects,
1288 stripe_count);
1289 } else if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) {
1290 lustre_swab_lov_user_md_v3((struct lov_user_md_v3 *)lmm);
1291 if (S_ISREG(body->mode))
1292 lustre_swab_lov_user_md_objects(
1293 ((struct lov_user_md_v3 *)lmm)->lmm_objects,
1294 stripe_count);
1295 }
1296 }
1297
1298out:
1299 *lmmp = lmm;
1300 *lmm_size = lmmsize;
1301 *request = req;
1302 return rc;
1303}
1304
1305static int ll_lov_setea(struct inode *inode, struct file *file,
1306 unsigned long arg)
1307{
1308 int flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE;
1309 struct lov_user_md *lump;
1310 int lum_size = sizeof(struct lov_user_md) +
1311 sizeof(struct lov_user_ost_data);
1312 int rc;
1313
1314 if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1315 return -EPERM;
1316
1317 OBD_ALLOC_LARGE(lump, lum_size);
1318 if (lump == NULL)
1319 return -ENOMEM;
1320
1321 if (copy_from_user(lump, (struct lov_user_md *)arg, lum_size)) {
1322 OBD_FREE_LARGE(lump, lum_size);
1323 return -EFAULT;
1324 }
1325
1326 rc = ll_lov_setstripe_ea_info(inode, file, flags, lump, lum_size);
1327
1328 OBD_FREE_LARGE(lump, lum_size);
1329 return rc;
1330}
1331
1332static int ll_lov_setstripe(struct inode *inode, struct file *file,
1333 unsigned long arg)
1334{
1335 struct lov_user_md_v3 lumv3;
1336 struct lov_user_md_v1 *lumv1 = (struct lov_user_md_v1 *)&lumv3;
1337 struct lov_user_md_v1 *lumv1p = (struct lov_user_md_v1 *)arg;
1338 struct lov_user_md_v3 *lumv3p = (struct lov_user_md_v3 *)arg;
1339 int lum_size, rc;
1340 int flags = FMODE_WRITE;
1341
1342
1343 lum_size = sizeof(struct lov_user_md_v1);
1344 if (copy_from_user(lumv1, lumv1p, lum_size))
1345 return -EFAULT;
1346
1347 if (lumv1->lmm_magic == LOV_USER_MAGIC_V3) {
1348 lum_size = sizeof(struct lov_user_md_v3);
1349 if (copy_from_user(&lumv3, lumv3p, lum_size))
1350 return -EFAULT;
1351 }
1352
1353 rc = ll_lov_setstripe_ea_info(inode, file, flags, lumv1, lum_size);
1354 if (rc == 0) {
1355 struct lov_stripe_md *lsm;
1356 __u32 gen;
1357
1358 put_user(0, &lumv1p->lmm_stripe_count);
1359
1360 ll_layout_refresh(inode, &gen);
1361 lsm = ccc_inode_lsm_get(inode);
1362 rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode),
1363 0, lsm, (void *)arg);
1364 ccc_inode_lsm_put(inode, lsm);
1365 }
1366 return rc;
1367}
1368
1369static int ll_lov_getstripe(struct inode *inode, unsigned long arg)
1370{
1371 struct lov_stripe_md *lsm;
1372 int rc = -ENODATA;
1373
1374 lsm = ccc_inode_lsm_get(inode);
1375 if (lsm != NULL)
1376 rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), 0,
1377 lsm, (void *)arg);
1378 ccc_inode_lsm_put(inode, lsm);
1379 return rc;
1380}
1381
1382int ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1383{
1384 struct ll_inode_info *lli = ll_i2info(inode);
1385 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
1386 struct ccc_grouplock grouplock;
1387 int rc;
1388
1389 if (ll_file_nolock(file))
1390 return -EOPNOTSUPP;
1391
1392 spin_lock(&lli->lli_lock);
1393 if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1394 CWARN("group lock already existed with gid %lu\n",
1395 fd->fd_grouplock.cg_gid);
1396 spin_unlock(&lli->lli_lock);
1397 return -EINVAL;
1398 }
1399 LASSERT(fd->fd_grouplock.cg_lock == NULL);
1400 spin_unlock(&lli->lli_lock);
1401
1402 rc = cl_get_grouplock(cl_i2info(inode)->lli_clob,
1403 arg, (file->f_flags & O_NONBLOCK), &grouplock);
1404 if (rc)
1405 return rc;
1406
1407 spin_lock(&lli->lli_lock);
1408 if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1409 spin_unlock(&lli->lli_lock);
1410 CERROR("another thread just won the race\n");
1411 cl_put_grouplock(&grouplock);
1412 return -EINVAL;
1413 }
1414
1415 fd->fd_flags |= LL_FILE_GROUP_LOCKED;
1416 fd->fd_grouplock = grouplock;
1417 spin_unlock(&lli->lli_lock);
1418
1419 CDEBUG(D_INFO, "group lock %lu obtained\n", arg);
1420 return 0;
1421}
1422
1423int ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1424{
1425 struct ll_inode_info *lli = ll_i2info(inode);
1426 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
1427 struct ccc_grouplock grouplock;
1428
1429 spin_lock(&lli->lli_lock);
1430 if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1431 spin_unlock(&lli->lli_lock);
1432 CWARN("no group lock held\n");
1433 return -EINVAL;
1434 }
1435 LASSERT(fd->fd_grouplock.cg_lock != NULL);
1436
1437 if (fd->fd_grouplock.cg_gid != arg) {
1438 CWARN("group lock %lu doesn't match current id %lu\n",
1439 arg, fd->fd_grouplock.cg_gid);
1440 spin_unlock(&lli->lli_lock);
1441 return -EINVAL;
1442 }
1443
1444 grouplock = fd->fd_grouplock;
1445 memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock));
1446 fd->fd_flags &= ~LL_FILE_GROUP_LOCKED;
1447 spin_unlock(&lli->lli_lock);
1448
1449 cl_put_grouplock(&grouplock);
1450 CDEBUG(D_INFO, "group lock %lu released\n", arg);
1451 return 0;
1452}
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
1464{
1465 struct inode *inode = dentry->d_inode;
1466 struct obd_client_handle *och;
1467 int rc;
1468
1469 LASSERT(inode);
1470
1471
1472 if (dentry->d_inode->i_sb->s_root == dentry)
1473 return 0;
1474
1475
1476 if (!it_disposition(it, DISP_OPEN_OPEN))
1477 return 0;
1478
1479 LASSERT(it_open_error(DISP_OPEN_OPEN, it) == 0);
1480
1481 OBD_ALLOC(och, sizeof(*och));
1482 if (!och)
1483 GOTO(out, rc = -ENOMEM);
1484
1485 ll_och_fill(ll_i2sbi(inode)->ll_md_exp,
1486 ll_i2info(inode), it, och);
1487
1488 rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp,
1489 inode, och);
1490 out:
1491
1492 if (it_disposition(it, DISP_ENQ_OPEN_REF)) {
1493 ptlrpc_req_finished(it->d.lustre.it_data);
1494 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
1495 }
1496 return rc;
1497}
1498
1499
1500
1501
1502
1503int ll_do_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap,
1504 int num_bytes)
1505{
1506 struct obd_export *exp = ll_i2dtexp(inode);
1507 struct lov_stripe_md *lsm = NULL;
1508 struct ll_fiemap_info_key fm_key = { .name = KEY_FIEMAP, };
1509 int vallen = num_bytes;
1510 int rc;
1511
1512
1513 if (fiemap->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) {
1514 fiemap->fm_flags &= ~LUSTRE_FIEMAP_FLAGS_COMPAT;
1515 return -EBADR;
1516 }
1517
1518
1519 if (fiemap->fm_flags & FIEMAP_FLAG_SYNC) {
1520 rc = filemap_fdatawrite(inode->i_mapping);
1521 if (rc)
1522 return rc;
1523 }
1524
1525 lsm = ccc_inode_lsm_get(inode);
1526 if (lsm == NULL)
1527 return -ENOENT;
1528
1529
1530
1531
1532 if (lsm->lsm_stripe_count > 1 &&
1533 !(fiemap->fm_flags & FIEMAP_FLAG_DEVICE_ORDER))
1534 GOTO(out, rc = -EOPNOTSUPP);
1535
1536 fm_key.oa.o_oi = lsm->lsm_oi;
1537 fm_key.oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
1538
1539 obdo_from_inode(&fm_key.oa, inode, OBD_MD_FLSIZE);
1540 obdo_set_parent_fid(&fm_key.oa, &ll_i2info(inode)->lli_fid);
1541
1542 if (fm_key.oa.o_size == 0) {
1543 fiemap->fm_mapped_extents = 0;
1544 GOTO(out, rc = 0);
1545 }
1546
1547 memcpy(&fm_key.fiemap, fiemap, sizeof(*fiemap));
1548
1549 rc = obd_get_info(NULL, exp, sizeof(fm_key), &fm_key, &vallen,
1550 fiemap, lsm);
1551 if (rc)
1552 CERROR("obd_get_info failed: rc = %d\n", rc);
1553
1554out:
1555 ccc_inode_lsm_put(inode, lsm);
1556 return rc;
1557}
1558
1559int ll_fid2path(struct inode *inode, void *arg)
1560{
1561 struct obd_export *exp = ll_i2mdexp(inode);
1562 struct getinfo_fid2path *gfout, *gfin;
1563 int outsize, rc;
1564
1565 if (!cfs_capable(CFS_CAP_DAC_READ_SEARCH) &&
1566 !(ll_i2sbi(inode)->ll_flags & LL_SBI_USER_FID2PATH))
1567 return -EPERM;
1568
1569
1570 OBD_ALLOC_PTR(gfin);
1571 if (gfin == NULL)
1572 return -ENOMEM;
1573 if (copy_from_user(gfin, arg, sizeof(*gfin))) {
1574 OBD_FREE_PTR(gfin);
1575 return -EFAULT;
1576 }
1577
1578 outsize = sizeof(*gfout) + gfin->gf_pathlen;
1579 OBD_ALLOC(gfout, outsize);
1580 if (gfout == NULL) {
1581 OBD_FREE_PTR(gfin);
1582 return -ENOMEM;
1583 }
1584 memcpy(gfout, gfin, sizeof(*gfout));
1585 OBD_FREE_PTR(gfin);
1586
1587
1588 rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL);
1589 if (rc)
1590 GOTO(gf_free, rc);
1591
1592 if (copy_to_user(arg, gfout, outsize))
1593 rc = -EFAULT;
1594
1595gf_free:
1596 OBD_FREE(gfout, outsize);
1597 return rc;
1598}
1599
1600static int ll_ioctl_fiemap(struct inode *inode, unsigned long arg)
1601{
1602 struct ll_user_fiemap *fiemap_s;
1603 size_t num_bytes, ret_bytes;
1604 unsigned int extent_count;
1605 int rc = 0;
1606
1607
1608
1609 if (get_user(extent_count,
1610 &((struct ll_user_fiemap __user *)arg)->fm_extent_count))
1611 return -EFAULT;
1612 num_bytes = sizeof(*fiemap_s) + (extent_count *
1613 sizeof(struct ll_fiemap_extent));
1614
1615 OBD_ALLOC_LARGE(fiemap_s, num_bytes);
1616 if (fiemap_s == NULL)
1617 return -ENOMEM;
1618
1619
1620 if (copy_from_user(fiemap_s, (struct ll_user_fiemap __user *)arg,
1621 sizeof(*fiemap_s)))
1622 GOTO(error, rc = -EFAULT);
1623
1624
1625
1626
1627 if (extent_count) {
1628 if (copy_from_user(&fiemap_s->fm_extents[0],
1629 (char __user *)arg + sizeof(*fiemap_s),
1630 sizeof(struct ll_fiemap_extent)))
1631 GOTO(error, rc = -EFAULT);
1632 }
1633
1634 rc = ll_do_fiemap(inode, fiemap_s, num_bytes);
1635 if (rc)
1636 GOTO(error, rc);
1637
1638 ret_bytes = sizeof(struct ll_user_fiemap);
1639
1640 if (extent_count != 0)
1641 ret_bytes += (fiemap_s->fm_mapped_extents *
1642 sizeof(struct ll_fiemap_extent));
1643
1644 if (copy_to_user((void *)arg, fiemap_s, ret_bytes))
1645 rc = -EFAULT;
1646
1647error:
1648 OBD_FREE_LARGE(fiemap_s, num_bytes);
1649 return rc;
1650}
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661int ll_data_version(struct inode *inode, __u64 *data_version,
1662 int extent_lock)
1663{
1664 struct lov_stripe_md *lsm = NULL;
1665 struct ll_sb_info *sbi = ll_i2sbi(inode);
1666 struct obdo *obdo = NULL;
1667 int rc;
1668
1669
1670 lsm = ccc_inode_lsm_get(inode);
1671 if (!lsm_has_objects(lsm)) {
1672 *data_version = 0;
1673 CDEBUG(D_INODE, "No object for inode\n");
1674 GOTO(out, rc = 0);
1675 }
1676
1677 OBD_ALLOC_PTR(obdo);
1678 if (obdo == NULL)
1679 GOTO(out, rc = -ENOMEM);
1680
1681 rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, obdo, 0, extent_lock);
1682 if (rc == 0) {
1683 if (!(obdo->o_valid & OBD_MD_FLDATAVERSION))
1684 rc = -EOPNOTSUPP;
1685 else
1686 *data_version = obdo->o_data_version;
1687 }
1688
1689 OBD_FREE_PTR(obdo);
1690out:
1691 ccc_inode_lsm_put(inode, lsm);
1692 return rc;
1693}
1694
1695struct ll_swap_stack {
1696 struct iattr ia1, ia2;
1697 __u64 dv1, dv2;
1698 struct inode *inode1, *inode2;
1699 bool check_dv1, check_dv2;
1700};
1701
1702static int ll_swap_layouts(struct file *file1, struct file *file2,
1703 struct lustre_swap_layouts *lsl)
1704{
1705 struct mdc_swap_layouts msl;
1706 struct md_op_data *op_data;
1707 __u32 gid;
1708 __u64 dv;
1709 struct ll_swap_stack *llss = NULL;
1710 int rc;
1711
1712 OBD_ALLOC_PTR(llss);
1713 if (llss == NULL)
1714 return -ENOMEM;
1715
1716 llss->inode1 = file1->f_dentry->d_inode;
1717 llss->inode2 = file2->f_dentry->d_inode;
1718
1719 if (!S_ISREG(llss->inode2->i_mode))
1720 GOTO(free, rc = -EINVAL);
1721
1722 if (inode_permission(llss->inode1, MAY_WRITE) ||
1723 inode_permission(llss->inode2, MAY_WRITE))
1724 GOTO(free, rc = -EPERM);
1725
1726 if (llss->inode2->i_sb != llss->inode1->i_sb)
1727 GOTO(free, rc = -EXDEV);
1728
1729
1730 if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV1)
1731 llss->check_dv1 = true;
1732
1733 if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV2)
1734 llss->check_dv2 = true;
1735
1736
1737 llss->dv1 = lsl->sl_dv1;
1738 llss->dv2 = lsl->sl_dv2;
1739
1740 rc = lu_fid_cmp(ll_inode2fid(llss->inode1), ll_inode2fid(llss->inode2));
1741 if (rc == 0)
1742 GOTO(free, rc = 0);
1743
1744 if (rc < 0) {
1745 swap(llss->inode1, llss->inode2);
1746 swap(file1, file2);
1747 swap(llss->dv1, llss->dv2);
1748 swap(llss->check_dv1, llss->check_dv2);
1749 }
1750
1751 gid = lsl->sl_gid;
1752 if (gid != 0) {
1753 rc = ll_get_grouplock(llss->inode1, file1, gid);
1754 if (rc < 0)
1755 GOTO(free, rc);
1756
1757 rc = ll_get_grouplock(llss->inode2, file2, gid);
1758 if (rc < 0) {
1759 ll_put_grouplock(llss->inode1, file1, gid);
1760 GOTO(free, rc);
1761 }
1762 }
1763
1764
1765
1766 if (lsl->sl_flags &
1767 (SWAP_LAYOUTS_KEEP_MTIME | SWAP_LAYOUTS_KEEP_ATIME)) {
1768 llss->ia1.ia_mtime = llss->inode1->i_mtime;
1769 llss->ia1.ia_atime = llss->inode1->i_atime;
1770 llss->ia1.ia_valid = ATTR_MTIME | ATTR_ATIME;
1771 llss->ia2.ia_mtime = llss->inode2->i_mtime;
1772 llss->ia2.ia_atime = llss->inode2->i_atime;
1773 llss->ia2.ia_valid = ATTR_MTIME | ATTR_ATIME;
1774 }
1775
1776
1777
1778 if (llss->check_dv1) {
1779 rc = ll_data_version(llss->inode1, &dv, 0);
1780 if (rc)
1781 GOTO(putgl, rc);
1782 if (dv != llss->dv1)
1783 GOTO(putgl, rc = -EAGAIN);
1784 }
1785
1786 if (llss->check_dv2) {
1787 rc = ll_data_version(llss->inode2, &dv, 0);
1788 if (rc)
1789 GOTO(putgl, rc);
1790 if (dv != llss->dv2)
1791 GOTO(putgl, rc = -EAGAIN);
1792 }
1793
1794
1795
1796
1797
1798
1799 msl.msl_flags = 0;
1800 rc = -ENOMEM;
1801 op_data = ll_prep_md_op_data(NULL, llss->inode1, llss->inode2, NULL, 0,
1802 0, LUSTRE_OPC_ANY, &msl);
1803 if (IS_ERR(op_data))
1804 GOTO(free, rc = PTR_ERR(op_data));
1805
1806 rc = obd_iocontrol(LL_IOC_LOV_SWAP_LAYOUTS, ll_i2mdexp(llss->inode1),
1807 sizeof(*op_data), op_data, NULL);
1808 ll_finish_md_op_data(op_data);
1809
1810putgl:
1811 if (gid != 0) {
1812 ll_put_grouplock(llss->inode2, file2, gid);
1813 ll_put_grouplock(llss->inode1, file1, gid);
1814 }
1815
1816
1817 if (rc != 0)
1818 GOTO(free, rc);
1819
1820
1821 if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_MTIME)) {
1822 llss->ia1.ia_valid &= ~ATTR_MTIME;
1823 llss->ia2.ia_valid &= ~ATTR_MTIME;
1824 }
1825
1826 if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_ATIME)) {
1827 llss->ia1.ia_valid &= ~ATTR_ATIME;
1828 llss->ia2.ia_valid &= ~ATTR_ATIME;
1829 }
1830
1831
1832 rc = 0;
1833 if (llss->ia2.ia_valid != 0) {
1834 mutex_lock(&llss->inode1->i_mutex);
1835 rc = ll_setattr(file1->f_dentry, &llss->ia2);
1836 mutex_unlock(&llss->inode1->i_mutex);
1837 }
1838
1839 if (llss->ia1.ia_valid != 0) {
1840 int rc1;
1841
1842 mutex_lock(&llss->inode2->i_mutex);
1843 rc1 = ll_setattr(file2->f_dentry, &llss->ia1);
1844 mutex_unlock(&llss->inode2->i_mutex);
1845 if (rc == 0)
1846 rc = rc1;
1847 }
1848
1849free:
1850 if (llss != NULL)
1851 OBD_FREE_PTR(llss);
1852
1853 return rc;
1854}
1855
1856long ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1857{
1858 struct inode *inode = file->f_dentry->d_inode;
1859 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
1860 int flags, rc;
1861
1862 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),cmd=%x\n", inode->i_ino,
1863 inode->i_generation, inode, cmd);
1864 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
1865
1866
1867 if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't')
1868 return -ENOTTY;
1869
1870 switch(cmd) {
1871 case LL_IOC_GETFLAGS:
1872
1873 return put_user(fd->fd_flags, (int *)arg);
1874 case LL_IOC_SETFLAGS:
1875 case LL_IOC_CLRFLAGS:
1876
1877
1878
1879
1880 if (get_user(flags, (int *) arg))
1881 return -EFAULT;
1882
1883 if (cmd == LL_IOC_SETFLAGS) {
1884 if ((flags & LL_FILE_IGNORE_LOCK) &&
1885 !(file->f_flags & O_DIRECT)) {
1886 CERROR("%s: unable to disable locking on "
1887 "non-O_DIRECT file\n", current->comm);
1888 return -EINVAL;
1889 }
1890
1891 fd->fd_flags |= flags;
1892 } else {
1893 fd->fd_flags &= ~flags;
1894 }
1895 return 0;
1896 case LL_IOC_LOV_SETSTRIPE:
1897 return ll_lov_setstripe(inode, file, arg);
1898 case LL_IOC_LOV_SETEA:
1899 return ll_lov_setea(inode, file, arg);
1900 case LL_IOC_LOV_SWAP_LAYOUTS: {
1901 struct file *file2;
1902 struct lustre_swap_layouts lsl;
1903
1904 if (copy_from_user(&lsl, (char *)arg,
1905 sizeof(struct lustre_swap_layouts)))
1906 return -EFAULT;
1907
1908 if ((file->f_flags & O_ACCMODE) == 0)
1909 return -EPERM;
1910
1911 file2 = fget(lsl.sl_fd);
1912 if (file2 == NULL)
1913 return -EBADF;
1914
1915 rc = -EPERM;
1916 if ((file2->f_flags & O_ACCMODE) != 0)
1917 rc = ll_swap_layouts(file, file2, &lsl);
1918 fput(file2);
1919 return rc;
1920 }
1921 case LL_IOC_LOV_GETSTRIPE:
1922 return ll_lov_getstripe(inode, arg);
1923 case LL_IOC_RECREATE_OBJ:
1924 return ll_lov_recreate_obj(inode, arg);
1925 case LL_IOC_RECREATE_FID:
1926 return ll_lov_recreate_fid(inode, arg);
1927 case FSFILT_IOC_FIEMAP:
1928 return ll_ioctl_fiemap(inode, arg);
1929 case FSFILT_IOC_GETFLAGS:
1930 case FSFILT_IOC_SETFLAGS:
1931 return ll_iocontrol(inode, file, cmd, arg);
1932 case FSFILT_IOC_GETVERSION_OLD:
1933 case FSFILT_IOC_GETVERSION:
1934 return put_user(inode->i_generation, (int *)arg);
1935 case LL_IOC_GROUP_LOCK:
1936 return ll_get_grouplock(inode, file, arg);
1937 case LL_IOC_GROUP_UNLOCK:
1938 return ll_put_grouplock(inode, file, arg);
1939 case IOC_OBD_STATFS:
1940 return ll_obd_statfs(inode, (void *)arg);
1941
1942
1943
1944
1945
1946
1947
1948 case LL_IOC_FLUSHCTX:
1949 return ll_flush_ctx(inode);
1950 case LL_IOC_PATH2FID: {
1951 if (copy_to_user((void *)arg, ll_inode2fid(inode),
1952 sizeof(struct lu_fid)))
1953 return -EFAULT;
1954
1955 return 0;
1956 }
1957 case OBD_IOC_FID2PATH:
1958 return ll_fid2path(inode, (void *)arg);
1959 case LL_IOC_DATA_VERSION: {
1960 struct ioc_data_version idv;
1961 int rc;
1962
1963 if (copy_from_user(&idv, (char *)arg, sizeof(idv)))
1964 return -EFAULT;
1965
1966 rc = ll_data_version(inode, &idv.idv_version,
1967 !(idv.idv_flags & LL_DV_NOFLUSH));
1968
1969 if (rc == 0 && copy_to_user((char *) arg, &idv, sizeof(idv)))
1970 return -EFAULT;
1971
1972 return rc;
1973 }
1974
1975 case LL_IOC_GET_MDTIDX: {
1976 int mdtidx;
1977
1978 mdtidx = ll_get_mdt_idx(inode);
1979 if (mdtidx < 0)
1980 return mdtidx;
1981
1982 if (put_user((int)mdtidx, (int*)arg))
1983 return -EFAULT;
1984
1985 return 0;
1986 }
1987 case OBD_IOC_GETDTNAME:
1988 case OBD_IOC_GETMDNAME:
1989 return ll_get_obd_name(inode, cmd, arg);
1990 case LL_IOC_HSM_STATE_GET: {
1991 struct md_op_data *op_data;
1992 struct hsm_user_state *hus;
1993 int rc;
1994
1995 OBD_ALLOC_PTR(hus);
1996 if (hus == NULL)
1997 return -ENOMEM;
1998
1999 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2000 LUSTRE_OPC_ANY, hus);
2001 if (IS_ERR(op_data)) {
2002 OBD_FREE_PTR(hus);
2003 return PTR_ERR(op_data);
2004 }
2005
2006 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2007 op_data, NULL);
2008
2009 if (copy_to_user((void *)arg, hus, sizeof(*hus)))
2010 rc = -EFAULT;
2011
2012 ll_finish_md_op_data(op_data);
2013 OBD_FREE_PTR(hus);
2014 return rc;
2015 }
2016 case LL_IOC_HSM_STATE_SET: {
2017 struct md_op_data *op_data;
2018 struct hsm_state_set *hss;
2019 int rc;
2020
2021 OBD_ALLOC_PTR(hss);
2022 if (hss == NULL)
2023 return -ENOMEM;
2024 if (copy_from_user(hss, (char *)arg, sizeof(*hss))) {
2025 OBD_FREE_PTR(hss);
2026 return -EFAULT;
2027 }
2028
2029
2030
2031 if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK)
2032 && !cfs_capable(CFS_CAP_SYS_ADMIN)) {
2033 OBD_FREE_PTR(hss);
2034 return -EPERM;
2035 }
2036
2037 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2038 LUSTRE_OPC_ANY, hss);
2039 if (IS_ERR(op_data)) {
2040 OBD_FREE_PTR(hss);
2041 return PTR_ERR(op_data);
2042 }
2043
2044 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2045 op_data, NULL);
2046
2047 ll_finish_md_op_data(op_data);
2048
2049 OBD_FREE_PTR(hss);
2050 return rc;
2051 }
2052 case LL_IOC_HSM_ACTION: {
2053 struct md_op_data *op_data;
2054 struct hsm_current_action *hca;
2055 int rc;
2056
2057 OBD_ALLOC_PTR(hca);
2058 if (hca == NULL)
2059 return -ENOMEM;
2060
2061 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2062 LUSTRE_OPC_ANY, hca);
2063 if (IS_ERR(op_data)) {
2064 OBD_FREE_PTR(hca);
2065 return PTR_ERR(op_data);
2066 }
2067
2068 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2069 op_data, NULL);
2070
2071 if (copy_to_user((char *)arg, hca, sizeof(*hca)))
2072 rc = -EFAULT;
2073
2074 ll_finish_md_op_data(op_data);
2075 OBD_FREE_PTR(hca);
2076 return rc;
2077 }
2078 default: {
2079 int err;
2080
2081 if (LLIOC_STOP ==
2082 ll_iocontrol_call(inode, file, cmd, arg, &err))
2083 return err;
2084
2085 return obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL,
2086 (void *)arg);
2087 }
2088 }
2089}
2090
2091
2092loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
2093{
2094 struct inode *inode = file->f_dentry->d_inode;
2095 loff_t retval, eof = 0;
2096
2097 retval = offset + ((origin == SEEK_END) ? i_size_read(inode) :
2098 (origin == SEEK_CUR) ? file->f_pos : 0);
2099 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%llu=%#llx(%d)\n",
2100 inode->i_ino, inode->i_generation, inode, retval, retval,
2101 origin);
2102 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
2103
2104 if (origin == SEEK_END || origin == SEEK_HOLE || origin == SEEK_DATA) {
2105 retval = ll_glimpse_size(inode);
2106 if (retval != 0)
2107 return retval;
2108 eof = i_size_read(inode);
2109 }
2110
2111 retval = generic_file_llseek_size(file, offset, origin,
2112 ll_file_maxbytes(inode), eof);
2113 return retval;
2114}
2115
2116int ll_flush(struct file *file, fl_owner_t id)
2117{
2118 struct inode *inode = file->f_dentry->d_inode;
2119 struct ll_inode_info *lli = ll_i2info(inode);
2120 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2121 int rc, err;
2122
2123 LASSERT(!S_ISDIR(inode->i_mode));
2124
2125
2126
2127 rc = lli->lli_async_rc;
2128 lli->lli_async_rc = 0;
2129 err = lov_read_and_clear_async_rc(lli->lli_clob);
2130 if (rc == 0)
2131 rc = err;
2132
2133
2134
2135 if (fd->fd_write_failed)
2136 return 0;
2137 return rc ? -EIO : 0;
2138}
2139
2140
2141
2142
2143
2144
2145
2146int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end,
2147 enum cl_fsync_mode mode, int ignore_layout)
2148{
2149 struct cl_env_nest nest;
2150 struct lu_env *env;
2151 struct cl_io *io;
2152 struct obd_capa *capa = NULL;
2153 struct cl_fsync_io *fio;
2154 int result;
2155
2156 if (mode != CL_FSYNC_NONE && mode != CL_FSYNC_LOCAL &&
2157 mode != CL_FSYNC_DISCARD && mode != CL_FSYNC_ALL)
2158 return -EINVAL;
2159
2160 env = cl_env_nested_get(&nest);
2161 if (IS_ERR(env))
2162 return PTR_ERR(env);
2163
2164 capa = ll_osscapa_get(inode, CAPA_OPC_OSS_WRITE);
2165
2166 io = ccc_env_thread_io(env);
2167 io->ci_obj = cl_i2info(inode)->lli_clob;
2168 io->ci_ignore_layout = ignore_layout;
2169
2170
2171 fio = &io->u.ci_fsync;
2172 fio->fi_capa = capa;
2173 fio->fi_start = start;
2174 fio->fi_end = end;
2175 fio->fi_fid = ll_inode2fid(inode);
2176 fio->fi_mode = mode;
2177 fio->fi_nr_written = 0;
2178
2179 if (cl_io_init(env, io, CIT_FSYNC, io->ci_obj) == 0)
2180 result = cl_io_loop(env, io);
2181 else
2182 result = io->ci_result;
2183 if (result == 0)
2184 result = fio->fi_nr_written;
2185 cl_io_fini(env, io);
2186 cl_env_nested_put(&nest, env);
2187
2188 capa_put(capa);
2189
2190 return result;
2191}
2192
2193
2194
2195
2196
2197
2198
2199int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2200{
2201 struct dentry *dentry = file->f_dentry;
2202 struct inode *inode = dentry->d_inode;
2203 struct ll_inode_info *lli = ll_i2info(inode);
2204 struct ptlrpc_request *req;
2205 struct obd_capa *oc;
2206 int rc, err;
2207
2208 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
2209 inode->i_generation, inode);
2210 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
2211
2212 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2213 mutex_lock(&inode->i_mutex);
2214
2215
2216
2217 if (!S_ISDIR(inode->i_mode)) {
2218 err = lli->lli_async_rc;
2219 lli->lli_async_rc = 0;
2220 if (rc == 0)
2221 rc = err;
2222 err = lov_read_and_clear_async_rc(lli->lli_clob);
2223 if (rc == 0)
2224 rc = err;
2225 }
2226
2227 oc = ll_mdscapa_get(inode);
2228 err = md_sync(ll_i2sbi(inode)->ll_md_exp, ll_inode2fid(inode), oc,
2229 &req);
2230 capa_put(oc);
2231 if (!rc)
2232 rc = err;
2233 if (!err)
2234 ptlrpc_req_finished(req);
2235
2236 if (datasync && S_ISREG(inode->i_mode)) {
2237 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2238
2239 err = cl_sync_file_range(inode, 0, OBD_OBJECT_EOF,
2240 CL_FSYNC_ALL, 0);
2241 if (rc == 0 && err < 0)
2242 rc = err;
2243 if (rc < 0)
2244 fd->fd_write_failed = true;
2245 else
2246 fd->fd_write_failed = false;
2247 }
2248
2249 mutex_unlock(&inode->i_mutex);
2250 return rc;
2251}
2252
2253int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
2254{
2255 struct inode *inode = file->f_dentry->d_inode;
2256 struct ll_sb_info *sbi = ll_i2sbi(inode);
2257 struct ldlm_enqueue_info einfo = {
2258 .ei_type = LDLM_FLOCK,
2259 .ei_cb_cp = ldlm_flock_completion_ast,
2260 .ei_cbdata = file_lock,
2261 };
2262 struct md_op_data *op_data;
2263 struct lustre_handle lockh = {0};
2264 ldlm_policy_data_t flock = {{0}};
2265 int flags = 0;
2266 int rc;
2267 int rc2 = 0;
2268
2269 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu file_lock=%p\n",
2270 inode->i_ino, file_lock);
2271
2272 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
2273
2274 if (file_lock->fl_flags & FL_FLOCK) {
2275 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
2276
2277 flock.l_flock.end = OFFSET_MAX;
2278
2279 flock.l_flock.owner = (unsigned long)file_lock->fl_file;
2280 } else if (file_lock->fl_flags & FL_POSIX) {
2281 flock.l_flock.owner = (unsigned long)file_lock->fl_owner;
2282 flock.l_flock.start = file_lock->fl_start;
2283 flock.l_flock.end = file_lock->fl_end;
2284 } else {
2285 return -EINVAL;
2286 }
2287 flock.l_flock.pid = file_lock->fl_pid;
2288
2289
2290
2291
2292
2293
2294
2295
2296 if (file_lock->fl_lmops && file_lock->fl_lmops->lm_compare_owner)
2297 flock.l_flock.owner = (unsigned long)file_lock->fl_pid;
2298
2299 switch (file_lock->fl_type) {
2300 case F_RDLCK:
2301 einfo.ei_mode = LCK_PR;
2302 break;
2303 case F_UNLCK:
2304
2305
2306
2307
2308
2309
2310
2311
2312 einfo.ei_mode = LCK_NL;
2313 break;
2314 case F_WRLCK:
2315 einfo.ei_mode = LCK_PW;
2316 break;
2317 default:
2318 CDEBUG(D_INFO, "Unknown fcntl lock type: %d\n",
2319 file_lock->fl_type);
2320 return -ENOTSUPP;
2321 }
2322
2323 switch (cmd) {
2324 case F_SETLKW:
2325#ifdef F_SETLKW64
2326 case F_SETLKW64:
2327#endif
2328 flags = 0;
2329 break;
2330 case F_SETLK:
2331#ifdef F_SETLK64
2332 case F_SETLK64:
2333#endif
2334 flags = LDLM_FL_BLOCK_NOWAIT;
2335 break;
2336 case F_GETLK:
2337#ifdef F_GETLK64
2338 case F_GETLK64:
2339#endif
2340 flags = LDLM_FL_TEST_LOCK;
2341
2342
2343 file_lock->fl_type = einfo.ei_mode;
2344 break;
2345 default:
2346 CERROR("unknown fcntl lock command: %d\n", cmd);
2347 return -EINVAL;
2348 }
2349
2350 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2351 LUSTRE_OPC_ANY, NULL);
2352 if (IS_ERR(op_data))
2353 return PTR_ERR(op_data);
2354
2355 CDEBUG(D_DLMTRACE, "inode=%lu, pid=%u, flags=%#x, mode=%u, "
2356 "start="LPU64", end="LPU64"\n", inode->i_ino, flock.l_flock.pid,
2357 flags, einfo.ei_mode, flock.l_flock.start, flock.l_flock.end);
2358
2359 rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL,
2360 op_data, &lockh, &flock, 0, NULL , flags);
2361
2362 if ((file_lock->fl_flags & FL_FLOCK) &&
2363 (rc == 0 || file_lock->fl_type == F_UNLCK))
2364 rc2 = flock_lock_file_wait(file, file_lock);
2365 if ((file_lock->fl_flags & FL_POSIX) &&
2366 (rc == 0 || file_lock->fl_type == F_UNLCK) &&
2367 !(flags & LDLM_FL_TEST_LOCK))
2368 rc2 = posix_lock_file_wait(file, file_lock);
2369
2370 if (rc2 && file_lock->fl_type != F_UNLCK) {
2371 einfo.ei_mode = LCK_NL;
2372 md_enqueue(sbi->ll_md_exp, &einfo, NULL,
2373 op_data, &lockh, &flock, 0, NULL , flags);
2374 rc = rc2;
2375 }
2376
2377 ll_finish_md_op_data(op_data);
2378
2379 return rc;
2380}
2381
2382int ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
2383{
2384 return -ENOSYS;
2385}
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397int ll_have_md_lock(struct inode *inode, __u64 *bits, ldlm_mode_t l_req_mode)
2398{
2399 struct lustre_handle lockh;
2400 ldlm_policy_data_t policy;
2401 ldlm_mode_t mode = (l_req_mode == LCK_MINMODE) ?
2402 (LCK_CR|LCK_CW|LCK_PR|LCK_PW) : l_req_mode;
2403 struct lu_fid *fid;
2404 __u64 flags;
2405 int i;
2406
2407 if (!inode)
2408 return 0;
2409
2410 fid = &ll_i2info(inode)->lli_fid;
2411 CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
2412 ldlm_lockname[mode]);
2413
2414 flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
2415 for (i = 0; i <= MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) {
2416 policy.l_inodebits.bits = *bits & (1 << i);
2417 if (policy.l_inodebits.bits == 0)
2418 continue;
2419
2420 if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS,
2421 &policy, mode, &lockh)) {
2422 struct ldlm_lock *lock;
2423
2424 lock = ldlm_handle2lock(&lockh);
2425 if (lock) {
2426 *bits &=
2427 ~(lock->l_policy_data.l_inodebits.bits);
2428 LDLM_LOCK_PUT(lock);
2429 } else {
2430 *bits &= ~policy.l_inodebits.bits;
2431 }
2432 }
2433 }
2434 return *bits == 0;
2435}
2436
2437ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits,
2438 struct lustre_handle *lockh, __u64 flags)
2439{
2440 ldlm_policy_data_t policy = { .l_inodebits = {bits}};
2441 struct lu_fid *fid;
2442 ldlm_mode_t rc;
2443
2444 fid = &ll_i2info(inode)->lli_fid;
2445 CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
2446
2447 rc = md_lock_match(ll_i2mdexp(inode), LDLM_FL_BLOCK_GRANTED|flags,
2448 fid, LDLM_IBITS, &policy,
2449 LCK_CR|LCK_CW|LCK_PR|LCK_PW, lockh);
2450 return rc;
2451}
2452
2453static int ll_inode_revalidate_fini(struct inode *inode, int rc)
2454{
2455
2456 if (rc == -ENOENT) {
2457 clear_nlink(inode);
2458
2459
2460
2461 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
2462 return 0;
2463 } else if (rc != 0) {
2464 CERROR("%s: revalidate FID "DFID" error: rc = %d\n",
2465 ll_get_fsname(inode->i_sb, NULL, 0),
2466 PFID(ll_inode2fid(inode)), rc);
2467 }
2468
2469 return rc;
2470}
2471
2472int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
2473 __u64 ibits)
2474{
2475 struct inode *inode = dentry->d_inode;
2476 struct ptlrpc_request *req = NULL;
2477 struct obd_export *exp;
2478 int rc = 0;
2479
2480 LASSERT(inode != NULL);
2481
2482 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n",
2483 inode->i_ino, inode->i_generation, inode, dentry->d_name.name);
2484
2485 exp = ll_i2mdexp(inode);
2486
2487
2488
2489
2490 if (exp_connect_flags(exp) & OBD_CONNECT_ATTRFID) {
2491 struct lookup_intent oit = { .it_op = IT_GETATTR };
2492 struct md_op_data *op_data;
2493
2494 if (ibits == MDS_INODELOCK_LOOKUP)
2495 oit.it_op = IT_LOOKUP;
2496
2497
2498 op_data = ll_prep_md_op_data(NULL, dentry->d_parent->d_inode,
2499 dentry->d_inode, NULL, 0, 0,
2500 LUSTRE_OPC_ANY, NULL);
2501 if (IS_ERR(op_data))
2502 return PTR_ERR(op_data);
2503
2504 oit.it_create_mode |= M_CHECK_STALE;
2505 rc = md_intent_lock(exp, op_data, NULL, 0,
2506
2507
2508 &oit, 0, &req,
2509 ll_md_blocking_ast, 0);
2510 ll_finish_md_op_data(op_data);
2511 oit.it_create_mode &= ~M_CHECK_STALE;
2512 if (rc < 0) {
2513 rc = ll_inode_revalidate_fini(inode, rc);
2514 GOTO (out, rc);
2515 }
2516
2517 rc = ll_revalidate_it_finish(req, &oit, dentry);
2518 if (rc != 0) {
2519 ll_intent_release(&oit);
2520 GOTO(out, rc);
2521 }
2522
2523
2524
2525
2526
2527 if (!dentry->d_inode->i_nlink)
2528 d_lustre_invalidate(dentry, 0);
2529
2530 ll_lookup_finish_locks(&oit, dentry);
2531 } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
2532 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
2533 obd_valid valid = OBD_MD_FLGETATTR;
2534 struct md_op_data *op_data;
2535 int ealen = 0;
2536
2537 if (S_ISREG(inode->i_mode)) {
2538 rc = ll_get_max_mdsize(sbi, &ealen);
2539 if (rc)
2540 return rc;
2541 valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
2542 }
2543
2544 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
2545 0, ealen, LUSTRE_OPC_ANY,
2546 NULL);
2547 if (IS_ERR(op_data))
2548 return PTR_ERR(op_data);
2549
2550 op_data->op_valid = valid;
2551
2552
2553
2554 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
2555 ll_finish_md_op_data(op_data);
2556 if (rc) {
2557 rc = ll_inode_revalidate_fini(inode, rc);
2558 return rc;
2559 }
2560
2561 rc = ll_prep_inode(&inode, req, NULL, NULL);
2562 }
2563out:
2564 ptlrpc_req_finished(req);
2565 return rc;
2566}
2567
2568int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
2569 __u64 ibits)
2570{
2571 struct inode *inode = dentry->d_inode;
2572 int rc;
2573
2574 rc = __ll_inode_revalidate_it(dentry, it, ibits);
2575 if (rc != 0)
2576 return rc;
2577
2578
2579 if (!S_ISREG(inode->i_mode)) {
2580 LTIME_S(inode->i_atime) = ll_i2info(inode)->lli_lvb.lvb_atime;
2581 LTIME_S(inode->i_mtime) = ll_i2info(inode)->lli_lvb.lvb_mtime;
2582 LTIME_S(inode->i_ctime) = ll_i2info(inode)->lli_lvb.lvb_ctime;
2583 } else {
2584 rc = ll_glimpse_size(inode);
2585 }
2586 return rc;
2587}
2588
2589int ll_getattr_it(struct vfsmount *mnt, struct dentry *de,
2590 struct lookup_intent *it, struct kstat *stat)
2591{
2592 struct inode *inode = de->d_inode;
2593 struct ll_sb_info *sbi = ll_i2sbi(inode);
2594 struct ll_inode_info *lli = ll_i2info(inode);
2595 int res = 0;
2596
2597 res = ll_inode_revalidate_it(de, it, MDS_INODELOCK_UPDATE |
2598 MDS_INODELOCK_LOOKUP);
2599 ll_stats_ops_tally(sbi, LPROC_LL_GETATTR, 1);
2600
2601 if (res)
2602 return res;
2603
2604 stat->dev = inode->i_sb->s_dev;
2605 if (ll_need_32bit_api(sbi))
2606 stat->ino = cl_fid_build_ino(&lli->lli_fid, 1);
2607 else
2608 stat->ino = inode->i_ino;
2609 stat->mode = inode->i_mode;
2610 stat->nlink = inode->i_nlink;
2611 stat->uid = inode->i_uid;
2612 stat->gid = inode->i_gid;
2613 stat->rdev = inode->i_rdev;
2614 stat->atime = inode->i_atime;
2615 stat->mtime = inode->i_mtime;
2616 stat->ctime = inode->i_ctime;
2617 stat->blksize = 1 << inode->i_blkbits;
2618
2619 stat->size = i_size_read(inode);
2620 stat->blocks = inode->i_blocks;
2621
2622 return 0;
2623}
2624int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
2625{
2626 struct lookup_intent it = { .it_op = IT_GETATTR };
2627
2628 return ll_getattr_it(mnt, de, &it, stat);
2629}
2630
2631
2632struct posix_acl * ll_get_acl(struct inode *inode, int type)
2633{
2634 struct ll_inode_info *lli = ll_i2info(inode);
2635 struct posix_acl *acl = NULL;
2636
2637 spin_lock(&lli->lli_lock);
2638
2639 acl = posix_acl_dup(lli->lli_posix_acl);
2640 spin_unlock(&lli->lli_lock);
2641
2642 return acl;
2643}
2644
2645
2646int ll_inode_permission(struct inode *inode, int mask)
2647{
2648 int rc = 0;
2649
2650#ifdef MAY_NOT_BLOCK
2651 if (mask & MAY_NOT_BLOCK)
2652 return -ECHILD;
2653#endif
2654
2655
2656
2657
2658 if (inode == inode->i_sb->s_root->d_inode) {
2659 struct lookup_intent it = { .it_op = IT_LOOKUP };
2660
2661 rc = __ll_inode_revalidate_it(inode->i_sb->s_root, &it,
2662 MDS_INODELOCK_LOOKUP);
2663 if (rc)
2664 return rc;
2665 }
2666
2667 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), inode mode %x mask %o\n",
2668 inode->i_ino, inode->i_generation, inode, inode->i_mode, mask);
2669
2670 if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT)
2671 return lustre_check_remote_perm(inode, mask);
2672
2673 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
2674 rc = generic_permission(inode, mask);
2675
2676 return rc;
2677}
2678
2679#define READ_METHOD aio_read
2680#define READ_FUNCTION ll_file_aio_read
2681#define WRITE_METHOD aio_write
2682#define WRITE_FUNCTION ll_file_aio_write
2683
2684
2685struct file_operations ll_file_operations = {
2686 .read = ll_file_read,
2687 .READ_METHOD = READ_FUNCTION,
2688 .write = ll_file_write,
2689 .WRITE_METHOD = WRITE_FUNCTION,
2690 .unlocked_ioctl = ll_file_ioctl,
2691 .open = ll_file_open,
2692 .release = ll_file_release,
2693 .mmap = ll_file_mmap,
2694 .llseek = ll_file_seek,
2695 .splice_read = ll_file_splice_read,
2696 .fsync = ll_fsync,
2697 .flush = ll_flush
2698};
2699
2700struct file_operations ll_file_operations_flock = {
2701 .read = ll_file_read,
2702 .READ_METHOD = READ_FUNCTION,
2703 .write = ll_file_write,
2704 .WRITE_METHOD = WRITE_FUNCTION,
2705 .unlocked_ioctl = ll_file_ioctl,
2706 .open = ll_file_open,
2707 .release = ll_file_release,
2708 .mmap = ll_file_mmap,
2709 .llseek = ll_file_seek,
2710 .splice_read = ll_file_splice_read,
2711 .fsync = ll_fsync,
2712 .flush = ll_flush,
2713 .flock = ll_file_flock,
2714 .lock = ll_file_flock
2715};
2716
2717
2718struct file_operations ll_file_operations_noflock = {
2719 .read = ll_file_read,
2720 .READ_METHOD = READ_FUNCTION,
2721 .write = ll_file_write,
2722 .WRITE_METHOD = WRITE_FUNCTION,
2723 .unlocked_ioctl = ll_file_ioctl,
2724 .open = ll_file_open,
2725 .release = ll_file_release,
2726 .mmap = ll_file_mmap,
2727 .llseek = ll_file_seek,
2728 .splice_read = ll_file_splice_read,
2729 .fsync = ll_fsync,
2730 .flush = ll_flush,
2731 .flock = ll_file_noflock,
2732 .lock = ll_file_noflock
2733};
2734
2735struct inode_operations ll_file_inode_operations = {
2736 .setattr = ll_setattr,
2737 .getattr = ll_getattr,
2738 .permission = ll_inode_permission,
2739 .setxattr = ll_setxattr,
2740 .getxattr = ll_getxattr,
2741 .listxattr = ll_listxattr,
2742 .removexattr = ll_removexattr,
2743 .get_acl = ll_get_acl,
2744};
2745
2746
2747static struct llioc_ctl_data {
2748 struct rw_semaphore ioc_sem;
2749 struct list_head ioc_head;
2750} llioc = {
2751 __RWSEM_INITIALIZER(llioc.ioc_sem),
2752 LIST_HEAD_INIT(llioc.ioc_head)
2753};
2754
2755
2756struct llioc_data {
2757 struct list_head iocd_list;
2758 unsigned int iocd_size;
2759 llioc_callback_t iocd_cb;
2760 unsigned int iocd_count;
2761 unsigned int iocd_cmd[0];
2762};
2763
2764void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd)
2765{
2766 unsigned int size;
2767 struct llioc_data *in_data = NULL;
2768
2769 if (cb == NULL || cmd == NULL ||
2770 count > LLIOC_MAX_CMD || count < 0)
2771 return NULL;
2772
2773 size = sizeof(*in_data) + count * sizeof(unsigned int);
2774 OBD_ALLOC(in_data, size);
2775 if (in_data == NULL)
2776 return NULL;
2777
2778 memset(in_data, 0, sizeof(*in_data));
2779 in_data->iocd_size = size;
2780 in_data->iocd_cb = cb;
2781 in_data->iocd_count = count;
2782 memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count);
2783
2784 down_write(&llioc.ioc_sem);
2785 list_add_tail(&in_data->iocd_list, &llioc.ioc_head);
2786 up_write(&llioc.ioc_sem);
2787
2788 return in_data;
2789}
2790
2791void ll_iocontrol_unregister(void *magic)
2792{
2793 struct llioc_data *tmp;
2794
2795 if (magic == NULL)
2796 return;
2797
2798 down_write(&llioc.ioc_sem);
2799 list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) {
2800 if (tmp == magic) {
2801 unsigned int size = tmp->iocd_size;
2802
2803 list_del(&tmp->iocd_list);
2804 up_write(&llioc.ioc_sem);
2805
2806 OBD_FREE(tmp, size);
2807 return;
2808 }
2809 }
2810 up_write(&llioc.ioc_sem);
2811
2812 CWARN("didn't find iocontrol register block with magic: %p\n", magic);
2813}
2814
2815EXPORT_SYMBOL(ll_iocontrol_register);
2816EXPORT_SYMBOL(ll_iocontrol_unregister);
2817
2818enum llioc_iter ll_iocontrol_call(struct inode *inode, struct file *file,
2819 unsigned int cmd, unsigned long arg, int *rcp)
2820{
2821 enum llioc_iter ret = LLIOC_CONT;
2822 struct llioc_data *data;
2823 int rc = -EINVAL, i;
2824
2825 down_read(&llioc.ioc_sem);
2826 list_for_each_entry(data, &llioc.ioc_head, iocd_list) {
2827 for (i = 0; i < data->iocd_count; i++) {
2828 if (cmd != data->iocd_cmd[i])
2829 continue;
2830
2831 ret = data->iocd_cb(inode, file, cmd, arg, data, &rc);
2832 break;
2833 }
2834
2835 if (ret == LLIOC_STOP)
2836 break;
2837 }
2838 up_read(&llioc.ioc_sem);
2839
2840 if (rcp)
2841 *rcp = rc;
2842 return ret;
2843}
2844
2845int ll_layout_conf(struct inode *inode, const struct cl_object_conf *conf)
2846{
2847 struct ll_inode_info *lli = ll_i2info(inode);
2848 struct cl_env_nest nest;
2849 struct lu_env *env;
2850 int result;
2851
2852 if (lli->lli_clob == NULL)
2853 return 0;
2854
2855 env = cl_env_nested_get(&nest);
2856 if (IS_ERR(env))
2857 return PTR_ERR(env);
2858
2859 result = cl_conf_set(env, lli->lli_clob, conf);
2860 cl_env_nested_put(&nest, env);
2861
2862 if (conf->coc_opc == OBJECT_CONF_SET) {
2863 struct ldlm_lock *lock = conf->coc_lock;
2864
2865 LASSERT(lock != NULL);
2866 LASSERT(ldlm_has_layout(lock));
2867 if (result == 0) {
2868
2869
2870
2871
2872 ldlm_lock_allow_match(lock);
2873 }
2874 }
2875 return result;
2876}
2877
2878
2879static int ll_layout_fetch(struct inode *inode, struct ldlm_lock *lock)
2880
2881{
2882 struct ll_sb_info *sbi = ll_i2sbi(inode);
2883 struct obd_capa *oc;
2884 struct ptlrpc_request *req;
2885 struct mdt_body *body;
2886 void *lvbdata;
2887 void *lmm;
2888 int lmmsize;
2889 int rc;
2890
2891 CDEBUG(D_INODE, DFID" LVB_READY=%d l_lvb_data=%p l_lvb_len=%d\n",
2892 PFID(ll_inode2fid(inode)), !!(lock->l_flags & LDLM_FL_LVB_READY),
2893 lock->l_lvb_data, lock->l_lvb_len);
2894
2895 if ((lock->l_lvb_data != NULL) && (lock->l_flags & LDLM_FL_LVB_READY))
2896 return 0;
2897
2898
2899
2900
2901
2902
2903 oc = ll_mdscapa_get(inode);
2904 rc = ll_get_max_mdsize(sbi, &lmmsize);
2905 if (rc == 0)
2906 rc = md_getxattr(sbi->ll_md_exp, ll_inode2fid(inode), oc,
2907 OBD_MD_FLXATTR, XATTR_NAME_LOV, NULL, 0,
2908 lmmsize, 0, &req);
2909 capa_put(oc);
2910 if (rc < 0)
2911 return rc;
2912
2913 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
2914 if (body == NULL || body->eadatasize > lmmsize)
2915 GOTO(out, rc = -EPROTO);
2916
2917 lmmsize = body->eadatasize;
2918 if (lmmsize == 0)
2919 GOTO(out, rc = 0);
2920
2921 lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA, lmmsize);
2922 if (lmm == NULL)
2923 GOTO(out, rc = -EFAULT);
2924
2925 OBD_ALLOC_LARGE(lvbdata, lmmsize);
2926 if (lvbdata == NULL)
2927 GOTO(out, rc = -ENOMEM);
2928
2929 memcpy(lvbdata, lmm, lmmsize);
2930 lock_res_and_lock(lock);
2931 if (lock->l_lvb_data != NULL)
2932 OBD_FREE_LARGE(lock->l_lvb_data, lock->l_lvb_len);
2933
2934 lock->l_lvb_data = lvbdata;
2935 lock->l_lvb_len = lmmsize;
2936 unlock_res_and_lock(lock);
2937
2938out:
2939 ptlrpc_req_finished(req);
2940 return rc;
2941}
2942
2943
2944
2945
2946
2947static int ll_layout_lock_set(struct lustre_handle *lockh, ldlm_mode_t mode,
2948 struct inode *inode, __u32 *gen, bool reconf)
2949{
2950 struct ll_inode_info *lli = ll_i2info(inode);
2951 struct ll_sb_info *sbi = ll_i2sbi(inode);
2952 struct ldlm_lock *lock;
2953 struct lustre_md md = { NULL };
2954 struct cl_object_conf conf;
2955 int rc = 0;
2956 bool lvb_ready;
2957 bool wait_layout = false;
2958
2959 LASSERT(lustre_handle_is_used(lockh));
2960
2961 lock = ldlm_handle2lock(lockh);
2962 LASSERT(lock != NULL);
2963 LASSERT(ldlm_has_layout(lock));
2964
2965 LDLM_DEBUG(lock, "File %p/"DFID" being reconfigured: %d.\n",
2966 inode, PFID(&lli->lli_fid), reconf);
2967
2968
2969 md_set_lock_data(sbi->ll_md_exp, &lockh->cookie, inode, NULL);
2970
2971 lock_res_and_lock(lock);
2972 lvb_ready = !!(lock->l_flags & LDLM_FL_LVB_READY);
2973 unlock_res_and_lock(lock);
2974
2975
2976 if (lvb_ready || !reconf) {
2977 rc = -ENODATA;
2978 if (lvb_ready) {
2979
2980
2981 *gen = lli->lli_layout_gen;
2982 rc = 0;
2983 }
2984 GOTO(out, rc);
2985 }
2986
2987 rc = ll_layout_fetch(inode, lock);
2988 if (rc < 0)
2989 GOTO(out, rc);
2990
2991
2992
2993
2994
2995 if (lock->l_lvb_data != NULL) {
2996 rc = obd_unpackmd(sbi->ll_dt_exp, &md.lsm,
2997 lock->l_lvb_data, lock->l_lvb_len);
2998 if (rc >= 0) {
2999 *gen = LL_LAYOUT_GEN_EMPTY;
3000 if (md.lsm != NULL)
3001 *gen = md.lsm->lsm_layout_gen;
3002 rc = 0;
3003 } else {
3004 CERROR("%s: file "DFID" unpackmd error: %d\n",
3005 ll_get_fsname(inode->i_sb, NULL, 0),
3006 PFID(&lli->lli_fid), rc);
3007 }
3008 }
3009 if (rc < 0)
3010 GOTO(out, rc);
3011
3012
3013
3014 memset(&conf, 0, sizeof conf);
3015 conf.coc_opc = OBJECT_CONF_SET;
3016 conf.coc_inode = inode;
3017 conf.coc_lock = lock;
3018 conf.u.coc_md = &md;
3019 rc = ll_layout_conf(inode, &conf);
3020
3021 if (md.lsm != NULL)
3022 obd_free_memmd(sbi->ll_dt_exp, &md.lsm);
3023
3024
3025 wait_layout = rc == -EBUSY;
3026
3027out:
3028 LDLM_LOCK_PUT(lock);
3029 ldlm_lock_decref(lockh, mode);
3030
3031
3032 if (wait_layout) {
3033 CDEBUG(D_INODE, "%s: %p/"DFID" wait for layout reconf.\n",
3034 ll_get_fsname(inode->i_sb, NULL, 0),
3035 inode, PFID(&lli->lli_fid));
3036
3037 memset(&conf, 0, sizeof conf);
3038 conf.coc_opc = OBJECT_CONF_WAIT;
3039 conf.coc_inode = inode;
3040 rc = ll_layout_conf(inode, &conf);
3041 if (rc == 0)
3042 rc = -EAGAIN;
3043
3044 CDEBUG(D_INODE, "file: "DFID" waiting layout return: %d.\n",
3045 PFID(&lli->lli_fid), rc);
3046 }
3047 return rc;
3048}
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063int ll_layout_refresh(struct inode *inode, __u32 *gen)
3064{
3065 struct ll_inode_info *lli = ll_i2info(inode);
3066 struct ll_sb_info *sbi = ll_i2sbi(inode);
3067 struct md_op_data *op_data;
3068 struct lookup_intent it;
3069 struct lustre_handle lockh;
3070 ldlm_mode_t mode;
3071 struct ldlm_enqueue_info einfo = {
3072 .ei_type = LDLM_IBITS,
3073 .ei_mode = LCK_CR,
3074 .ei_cb_bl = ll_md_blocking_ast,
3075 .ei_cb_cp = ldlm_completion_ast,
3076 };
3077 int rc;
3078
3079 *gen = lli->lli_layout_gen;
3080 if (!(sbi->ll_flags & LL_SBI_LAYOUT_LOCK))
3081 return 0;
3082
3083
3084 LASSERT(fid_is_sane(ll_inode2fid(inode)));
3085 LASSERT(S_ISREG(inode->i_mode));
3086
3087
3088
3089 mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0);
3090 if (mode != 0) {
3091 rc = ll_layout_lock_set(&lockh, mode, inode, gen, false);
3092 if (rc == 0)
3093 return 0;
3094
3095
3096
3097 }
3098
3099
3100 mutex_lock(&lli->lli_layout_mutex);
3101
3102again:
3103
3104 mode = ll_take_md_lock(inode, MDS_INODELOCK_LAYOUT, &lockh, 0);
3105 if (mode != 0) {
3106 rc = ll_layout_lock_set(&lockh, mode, inode, gen, true);
3107 if (rc == -EAGAIN)
3108 goto again;
3109
3110 mutex_unlock(&lli->lli_layout_mutex);
3111 return rc;
3112 }
3113
3114 op_data = ll_prep_md_op_data(NULL, inode, inode, NULL,
3115 0, 0, LUSTRE_OPC_ANY, NULL);
3116 if (IS_ERR(op_data)) {
3117 mutex_unlock(&lli->lli_layout_mutex);
3118 return PTR_ERR(op_data);
3119 }
3120
3121
3122 memset(&it, 0, sizeof(it));
3123 it.it_op = IT_LAYOUT;
3124 lockh.cookie = 0ULL;
3125
3126 LDLM_DEBUG_NOLOCK("%s: requeue layout lock for file %p/"DFID".\n",
3127 ll_get_fsname(inode->i_sb, NULL, 0), inode,
3128 PFID(&lli->lli_fid));
3129
3130 rc = md_enqueue(sbi->ll_md_exp, &einfo, &it, op_data, &lockh,
3131 NULL, 0, NULL, 0);
3132 if (it.d.lustre.it_data != NULL)
3133 ptlrpc_req_finished(it.d.lustre.it_data);
3134 it.d.lustre.it_data = NULL;
3135
3136 ll_finish_md_op_data(op_data);
3137
3138 mode = it.d.lustre.it_lock_mode;
3139 it.d.lustre.it_lock_mode = 0;
3140 ll_intent_drop_lock(&it);
3141
3142 if (rc == 0) {
3143
3144 ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
3145 rc = ll_layout_lock_set(&lockh, mode, inode, gen, true);
3146 if (rc == -EAGAIN)
3147 goto again;
3148 }
3149 mutex_unlock(&lli->lli_layout_mutex);
3150
3151 return rc;
3152}
3153